From 67275a6382d95d89459714bb061c6393ffca1577 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 4 Nov 2019 19:22:14 +0200 Subject: [PATCH 01/25] tracing scaffolding --- gossipsub.go | 16 ++++++++++ pubsub.go | 17 ++++++++++ trace.go | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++ validation.go | 13 ++++++++ 4 files changed, 133 insertions(+) create mode 100644 trace.go diff --git a/gossipsub.go b/gossipsub.go index 1b2026c..e65f782 100644 --- a/gossipsub.go +++ b/gossipsub.go @@ -65,6 +65,7 @@ type GossipSubRouter struct { gossip map[peer.ID][]*pb.ControlIHave // pending gossip control map[peer.ID]*pb.ControlMessage // pending control messages mcache *MessageCache + tracer *pubsubTracer } func (gs *GossipSubRouter) Protocols() []protocol.ID { @@ -73,16 +74,21 @@ func (gs *GossipSubRouter) Protocols() []protocol.ID { func (gs *GossipSubRouter) Attach(p *PubSub) { gs.p = p + if p.tracer != nil { + gs.tracer = p.tracer + } go gs.heartbeatTimer() } func (gs *GossipSubRouter) AddPeer(p peer.ID, proto protocol.ID) { log.Debugf("PEERUP: Add new peer %s using %s", p, proto) + gs.tracer.AddPeer(p, proto) gs.peers[p] = proto } func (gs *GossipSubRouter) RemovePeer(p peer.ID) { log.Debugf("PEERDOWN: Remove disconnected peer %s", p) + gs.tracer.RemovePeer(p) delete(gs.peers, p) for _, peers := range gs.mesh { delete(peers, p) @@ -208,6 +214,7 @@ func (gs *GossipSubRouter) handleGraft(p peer.ID, ctl *pb.ControlMessage) []*pb. prune = append(prune, topic) } else { log.Debugf("GRAFT: Add mesh link from %s in %s", p, topic) + gs.tracer.Graft(p, topic) peers[p] = struct{}{} gs.tagPeer(p, topic) } @@ -231,6 +238,7 @@ func (gs *GossipSubRouter) handlePrune(p peer.ID, ctl *pb.ControlMessage) { peers, ok := gs.mesh[topic] if ok { log.Debugf("PRUNE: Remove mesh link to %s in %s", p, topic) + gs.tracer.Prune(p, topic) delete(peers, p) gs.untagPeer(p, topic) } @@ -294,6 +302,7 @@ func (gs *GossipSubRouter) Join(topic string) { } log.Debugf("JOIN %s", topic) + gs.tracer.Join(topic) gmap, ok = gs.fanout[topic] if ok { @@ -319,6 +328,7 @@ func (gs *GossipSubRouter) Join(topic string) { for p := range gmap { log.Debugf("JOIN: Add mesh link to %s in %s", p, topic) + gs.tracer.Graft(p, topic) gs.sendGraft(p, topic) gs.tagPeer(p, topic) } @@ -331,11 +341,13 @@ func (gs *GossipSubRouter) Leave(topic string) { } log.Debugf("LEAVE %s", topic) + gs.tracer.Leave(topic) delete(gs.mesh, topic) for p := range gmap { log.Debugf("LEAVE: Remove mesh link to %s in %s", p, topic) + gs.tracer.Prune(p, topic) gs.sendPrune(p, topic) gs.untagPeer(p, topic) } @@ -384,8 +396,10 @@ func (gs *GossipSubRouter) sendRPC(p peer.ID, out *RPC) { select { case mch <- out: + gs.tracer.SendRPC(out, p) default: log.Infof("dropping message to peer %s: queue full", p) + gs.tracer.DropRPC(out, p) // push control messages that need to be retried ctl := out.GetControl() if ctl != nil { @@ -443,6 +457,7 @@ func (gs *GossipSubRouter) heartbeat() { for _, p := range plst { log.Debugf("HEARTBEAT: Add mesh link to %s in %s", p, topic) + gs.tracer.Graft(p, topic) peers[p] = struct{}{} gs.tagPeer(p, topic) topics := tograft[p] @@ -458,6 +473,7 @@ func (gs *GossipSubRouter) heartbeat() { for _, p := range plst[:idontneed] { log.Debugf("HEARTBEAT: Remove mesh link to %s in %s", p, topic) + gs.tracer.Prune(p, topic) delete(peers, p) gs.untagPeer(p, topic) topics := toprune[p] diff --git a/pubsub.go b/pubsub.go index e46f4df..7237259 100644 --- a/pubsub.go +++ b/pubsub.go @@ -46,6 +46,8 @@ type PubSub struct { disc *discover + tracer *pubsubTracer + // size of the outbound message channel that we maintain for each peer peerOutboundQueueSize int @@ -321,6 +323,14 @@ func WithDiscovery(d discovery.Discovery, opts ...DiscoverOpt) Option { } } +// WithEventTracer provides a tracer for the pubsub system +func WithEventTracer(tracer EventTracer) Option { + return func(p *PubSub) error { + p.tracer = &pubsubTracer{tracer: tracer} + return nil + } +} + // processLoop handles all inputs arriving on the channels func (p *PubSub) processLoop(ctx context.Context) { defer func() { @@ -671,6 +681,8 @@ func (p *PubSub) notifyLeave(topic string, pid peer.ID) { } func (p *PubSub) handleIncomingRPC(rpc *RPC) { + p.tracer.RecvRPC(rpc) + for _, subopt := range rpc.GetSubscriptions() { t := subopt.GetTopicid() if subopt.GetSubscribe() { @@ -724,24 +736,28 @@ func (p *PubSub) pushMsg(msg *Message) { // reject messages from blacklisted peers if p.blacklist.Contains(src) { log.Warningf("dropping message from blacklisted peer %s", src) + p.tracer.RejectMessage(msg, "blacklisted peer") return } // even if they are forwarded by good peers if p.blacklist.Contains(msg.GetFrom()) { log.Warningf("dropping message from blacklisted source %s", src) + p.tracer.RejectMessage(msg, "blacklisted source") return } // reject unsigned messages when strict before we even process the id if p.signStrict && msg.Signature == nil { log.Debugf("dropping unsigned message from %s", src) + p.tracer.RejectMessage(msg, "missing signature") return } // have we already seen and validated this message? id := msgID(msg.Message) if p.seenMessage(id) { + p.tracer.DuplicateMessage(msg) return } @@ -755,6 +771,7 @@ func (p *PubSub) pushMsg(msg *Message) { } func (p *PubSub) publishMessage(msg *Message) { + p.tracer.DeliverMessage(msg) p.notifySubs(msg) p.rt.Publish(msg.ReceivedFrom, msg.Message) } diff --git a/trace.go b/trace.go new file mode 100644 index 0000000..08ec219 --- /dev/null +++ b/trace.go @@ -0,0 +1,87 @@ +package pubsub + +import ( + "github.com/libp2p/go-libp2p-core/peer" + "github.com/libp2p/go-libp2p-core/protocol" +) + +// Generic event tracer interface +type EventTracer interface { + Trace(evt interface{}) +} + +type pubsubTracer struct { + tracer EventTracer +} + +func (t *pubsubTracer) RejectMessage(msg *Message, reason string) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) DuplicateMessage(msg *Message) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) DeliverMessage(msg *Message) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) AddPeer(p peer.ID, proto protocol.ID) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) RemovePeer(p peer.ID) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) RecvRPC(rpc *RPC) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) SendRPC(rpc *RPC, p peer.ID) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) DropRPC(rpc *RPC, p peer.ID) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) Join(topic string) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) Leave(topic string) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) Graft(p peer.ID, topic string) { + if t != nil { + // TODO + } +} + +func (t *pubsubTracer) Prune(p peer.ID, topic string) { + if t != nil { + // TODO + } +} diff --git a/validation.go b/validation.go index 9253f2a..164bfa9 100644 --- a/validation.go +++ b/validation.go @@ -31,6 +31,8 @@ type ValidatorOpt func(addVal *addValReq) error type validation struct { p *PubSub + tracer *pubsubTracer + // topicVals tracks per topic validators topicVals map[string]*topicVal @@ -90,6 +92,9 @@ func newValidation() *validation { // workers func (v *validation) Start(p *PubSub) { v.p = p + if p.tracer != nil { + v.tracer = p.tracer + } for i := 0; i < v.validateWorkers; i++ { go v.validateWorker() } @@ -148,6 +153,7 @@ func (v *validation) Push(src peer.ID, msg *Message) bool { case v.validateQ <- &validateReq{vals, src, msg}: default: log.Warningf("message validation throttled; dropping message from %s", src) + v.tracer.RejectMessage(msg, "validation throttled") } return false } @@ -190,6 +196,7 @@ func (v *validation) validate(vals []*topicVal, src peer.ID, msg *Message) { if msg.Signature != nil { if !v.validateSignature(msg) { log.Warningf("message signature validation failed; dropping message from %s", src) + v.tracer.RejectMessage(msg, "invalid signature") return } } @@ -198,6 +205,7 @@ func (v *validation) validate(vals []*topicVal, src peer.ID, msg *Message) { // and avoid invoking user validators more than once id := msgID(msg.Message) if !v.p.markSeen(id) { + v.tracer.DuplicateMessage(msg) return } @@ -214,6 +222,7 @@ func (v *validation) validate(vals []*topicVal, src peer.ID, msg *Message) { for _, val := range inline { if !val.validateMsg(v.p.ctx, src, msg) { log.Debugf("message validation failed; dropping message from %s", src) + v.tracer.RejectMessage(msg, "validation failed") return } } @@ -228,6 +237,7 @@ func (v *validation) validate(vals []*topicVal, src peer.ID, msg *Message) { }() default: log.Warningf("message validation throttled; dropping message from %s", src) + v.tracer.RejectMessage(msg, "validation throttled") } return } @@ -249,6 +259,7 @@ func (v *validation) validateSignature(msg *Message) bool { func (v *validation) doValidateTopic(vals []*topicVal, src peer.ID, msg *Message) { if !v.validateTopic(vals, src, msg) { log.Warningf("message validation failed; dropping message from %s", src) + v.tracer.RejectMessage(msg, "validation failed") return } @@ -286,6 +297,7 @@ loop: } if throttle { + v.tracer.RejectMessage(msg, "validation throttled") return false } @@ -310,6 +322,7 @@ func (v *validation) validateSingleTopic(val *topicVal, src peer.ID, msg *Messag default: log.Debugf("validation throttled for topic %s", val.topic) + v.tracer.RejectMessage(msg, "validation throttled") return false } } From 89c7ed46e35f65f81bd4d4181e6c03251257cc2f Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 4 Nov 2019 20:04:55 +0200 Subject: [PATCH 02/25] trace publish --- pubsub.go | 1 + trace.go | 6 ++++++ 2 files changed, 7 insertions(+) diff --git a/pubsub.go b/pubsub.go index 7237259..d8fc964 100644 --- a/pubsub.go +++ b/pubsub.go @@ -446,6 +446,7 @@ func (p *PubSub) processLoop(ctx context.Context) { p.handleIncomingRPC(rpc) case msg := <-p.publish: + p.tracer.PublishMessage(msg) p.pushMsg(msg) case msg := <-p.sendMsg: diff --git a/trace.go b/trace.go index 08ec219..fc24f76 100644 --- a/trace.go +++ b/trace.go @@ -14,6 +14,12 @@ type pubsubTracer struct { tracer EventTracer } +func (t *pubsubTracer) PublishMessage(msg *Message) { + if t != nil { + // TODO + } +} + func (t *pubsubTracer) RejectMessage(msg *Message, reason string) { if t != nil { // TODO From fd739731453637c8f53addf523ab044c66a9f209 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 4 Nov 2019 20:43:48 +0200 Subject: [PATCH 03/25] add tracing to floodsub/randomsub --- floodsub.go | 22 ++++++++++++++++++---- randomsub.go | 20 ++++++++++++++++---- 2 files changed, 34 insertions(+), 8 deletions(-) diff --git a/floodsub.go b/floodsub.go index f70a0a7..63b4491 100644 --- a/floodsub.go +++ b/floodsub.go @@ -31,6 +31,7 @@ func NewFloodSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, err type FloodSubRouter struct { p *PubSub protocols []protocol.ID + tracer *pubsubTracer } func (fs *FloodSubRouter) Protocols() []protocol.ID { @@ -39,11 +40,18 @@ func (fs *FloodSubRouter) Protocols() []protocol.ID { func (fs *FloodSubRouter) Attach(p *PubSub) { fs.p = p + if p.tracer != nil { + fs.tracer = p.tracer + } } -func (fs *FloodSubRouter) AddPeer(peer.ID, protocol.ID) {} +func (fs *FloodSubRouter) AddPeer(p peer.ID, proto protocol.ID) { + fs.tracer.AddPeer(p, proto) +} -func (fs *FloodSubRouter) RemovePeer(peer.ID) {} +func (fs *FloodSubRouter) RemovePeer(p peer.ID) { + fs.tracer.RemovePeer(p) +} func (fs *FloodSubRouter) EnoughPeers(topic string, suggested int) bool { // check all peers in the topic @@ -91,13 +99,19 @@ func (fs *FloodSubRouter) Publish(from peer.ID, msg *pb.Message) { select { case mch <- out: + fs.tracer.SendRPC(out, pid) default: log.Infof("dropping message to peer %s: queue full", pid) + fs.tracer.DropRPC(out, pid) // Drop it. The peer is too slow. } } } -func (fs *FloodSubRouter) Join(topic string) {} +func (fs *FloodSubRouter) Join(topic string) { + fs.tracer.Join(topic) +} -func (fs *FloodSubRouter) Leave(topic string) {} +func (fs *FloodSubRouter) Leave(topic string) { + fs.tracer.Join(topic) +} diff --git a/randomsub.go b/randomsub.go index 9435c71..700e420 100644 --- a/randomsub.go +++ b/randomsub.go @@ -29,8 +29,9 @@ func NewRandomSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, er // RandomSubRouter is a router that implements a random propagation strategy. // For each message, it selects RandomSubD peers and forwards the message to them. type RandomSubRouter struct { - p *PubSub - peers map[peer.ID]protocol.ID + p *PubSub + peers map[peer.ID]protocol.ID + tracer *pubsubTracer } func (rs *RandomSubRouter) Protocols() []protocol.ID { @@ -39,13 +40,18 @@ func (rs *RandomSubRouter) Protocols() []protocol.ID { func (rs *RandomSubRouter) Attach(p *PubSub) { rs.p = p + if p.tracer != nil { + rs.tracer = p.tracer + } } func (rs *RandomSubRouter) AddPeer(p peer.ID, proto protocol.ID) { + rs.tracer.AddPeer(p, proto) rs.peers[p] = proto } func (rs *RandomSubRouter) RemovePeer(p peer.ID) { + rs.tracer.RemovePeer(p) delete(rs.peers, p) } @@ -132,12 +138,18 @@ func (rs *RandomSubRouter) Publish(from peer.ID, msg *pb.Message) { select { case mch <- out: + rs.tracer.SendRPC(out, p) default: log.Infof("dropping message to peer %s: queue full", p) + rs.tracer.DropRPC(out, p) } } } -func (rs *RandomSubRouter) Join(topic string) {} +func (rs *RandomSubRouter) Join(topic string) { + rs.tracer.Join(topic) +} -func (rs *RandomSubRouter) Leave(topic string) {} +func (rs *RandomSubRouter) Leave(topic string) { + rs.tracer.Join(topic) +} From 958e09a5b357f31b7f57a89c0150552c824bf3d5 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 4 Nov 2019 20:47:19 +0200 Subject: [PATCH 04/25] remove useless nil check when initializing subsystem tracers --- floodsub.go | 4 +--- gossipsub.go | 4 +--- randomsub.go | 4 +--- validation.go | 4 +--- 4 files changed, 4 insertions(+), 12 deletions(-) diff --git a/floodsub.go b/floodsub.go index 63b4491..3690f62 100644 --- a/floodsub.go +++ b/floodsub.go @@ -40,9 +40,7 @@ func (fs *FloodSubRouter) Protocols() []protocol.ID { func (fs *FloodSubRouter) Attach(p *PubSub) { fs.p = p - if p.tracer != nil { - fs.tracer = p.tracer - } + fs.tracer = p.tracer } func (fs *FloodSubRouter) AddPeer(p peer.ID, proto protocol.ID) { diff --git a/gossipsub.go b/gossipsub.go index e65f782..6327dfa 100644 --- a/gossipsub.go +++ b/gossipsub.go @@ -74,9 +74,7 @@ func (gs *GossipSubRouter) Protocols() []protocol.ID { func (gs *GossipSubRouter) Attach(p *PubSub) { gs.p = p - if p.tracer != nil { - gs.tracer = p.tracer - } + gs.tracer = p.tracer go gs.heartbeatTimer() } diff --git a/randomsub.go b/randomsub.go index 700e420..ffbfc62 100644 --- a/randomsub.go +++ b/randomsub.go @@ -40,9 +40,7 @@ func (rs *RandomSubRouter) Protocols() []protocol.ID { func (rs *RandomSubRouter) Attach(p *PubSub) { rs.p = p - if p.tracer != nil { - rs.tracer = p.tracer - } + rs.tracer = p.tracer } func (rs *RandomSubRouter) AddPeer(p peer.ID, proto protocol.ID) { diff --git a/validation.go b/validation.go index 164bfa9..bef86da 100644 --- a/validation.go +++ b/validation.go @@ -92,9 +92,7 @@ func newValidation() *validation { // workers func (v *validation) Start(p *PubSub) { v.p = p - if p.tracer != nil { - v.tracer = p.tracer - } + v.tracer = p.tracer for i := 0; i < v.validateWorkers; i++ { go v.validateWorker() } From fb11aa9857a3dfcc8a623166d173e51e639d8249 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 11 Nov 2019 18:32:12 +0200 Subject: [PATCH 05/25] initialize tracer with peer ID, trace RPC from join/leave announcements --- pubsub.go | 6 +++++- trace.go | 1 + 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/pubsub.go b/pubsub.go index d8fc964..530c47a 100644 --- a/pubsub.go +++ b/pubsub.go @@ -326,7 +326,7 @@ func WithDiscovery(d discovery.Discovery, opts ...DiscoverOpt) Option { // WithEventTracer provides a tracer for the pubsub system func WithEventTracer(tracer EventTracer) Option { return func(p *PubSub) error { - p.tracer = &pubsubTracer{tracer: tracer} + p.tracer = &pubsubTracer{tracer: tracer, pid: p.host.ID()} return nil } } @@ -582,8 +582,10 @@ func (p *PubSub) announce(topic string, sub bool) { for pid, peer := range p.peers { select { case peer <- out: + p.tracer.SendRPC(out, pid) default: log.Infof("Can't send announce message to peer %s: queue full; scheduling retry", pid) + p.tracer.DropRPC(out, pid) go p.announceRetry(pid, topic, sub) } } @@ -619,8 +621,10 @@ func (p *PubSub) doAnnounceRetry(pid peer.ID, topic string, sub bool) { out := rpcWithSubs(subopt) select { case peer <- out: + p.tracer.SendRPC(out, pid) default: log.Infof("Can't send announce message to peer %s: queue full; scheduling retry", pid) + p.tracer.DropRPC(out, pid) go p.announceRetry(pid, topic, sub) } } diff --git a/trace.go b/trace.go index fc24f76..99b4fa5 100644 --- a/trace.go +++ b/trace.go @@ -12,6 +12,7 @@ type EventTracer interface { type pubsubTracer struct { tracer EventTracer + pid peer.ID } func (t *pubsubTracer) PublishMessage(msg *Message) { From 0a25f248ea63d109b38636a178823e549a0eebc2 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 11 Nov 2019 18:33:48 +0200 Subject: [PATCH 06/25] trace event protobuf --- pb/trace.pb.go | 5543 ++++++++++++++++++++++++++++++++++++++++++++++++ pb/trace.proto | 135 ++ 2 files changed, 5678 insertions(+) create mode 100644 pb/trace.pb.go create mode 100644 pb/trace.proto diff --git a/pb/trace.pb.go b/pb/trace.pb.go new file mode 100644 index 0000000..5ed8d14 --- /dev/null +++ b/pb/trace.pb.go @@ -0,0 +1,5543 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: trace.proto + +package pubsub_pb + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type TraceEvent_Type int32 + +const ( + TraceEvent_PUBLISH_MESSAGE TraceEvent_Type = 0 + TraceEvent_REJECT_MESSAGE TraceEvent_Type = 1 + TraceEvent_DUPLICATE_MESSAGE TraceEvent_Type = 2 + TraceEvent_DELIVER_MESSAGE TraceEvent_Type = 3 + TraceEvent_ADD_PEER TraceEvent_Type = 4 + TraceEvent_REMOVE_PEER TraceEvent_Type = 5 + TraceEvent_RECV_RPC TraceEvent_Type = 6 + TraceEvent_SEND_RPC TraceEvent_Type = 7 + TraceEvent_DROP_RPC TraceEvent_Type = 8 + TraceEvent_JOIN TraceEvent_Type = 9 + TraceEvent_LEAE TraceEvent_Type = 10 + TraceEvent_GRAFT TraceEvent_Type = 11 + TraceEvent_PRUNE TraceEvent_Type = 12 +) + +var TraceEvent_Type_name = map[int32]string{ + 0: "PUBLISH_MESSAGE", + 1: "REJECT_MESSAGE", + 2: "DUPLICATE_MESSAGE", + 3: "DELIVER_MESSAGE", + 4: "ADD_PEER", + 5: "REMOVE_PEER", + 6: "RECV_RPC", + 7: "SEND_RPC", + 8: "DROP_RPC", + 9: "JOIN", + 10: "LEAE", + 11: "GRAFT", + 12: "PRUNE", +} +var TraceEvent_Type_value = map[string]int32{ + "PUBLISH_MESSAGE": 0, + "REJECT_MESSAGE": 1, + "DUPLICATE_MESSAGE": 2, + "DELIVER_MESSAGE": 3, + "ADD_PEER": 4, + "REMOVE_PEER": 5, + "RECV_RPC": 6, + "SEND_RPC": 7, + "DROP_RPC": 8, + "JOIN": 9, + "LEAE": 10, + "GRAFT": 11, + "PRUNE": 12, +} + +func (x TraceEvent_Type) Enum() *TraceEvent_Type { + p := new(TraceEvent_Type) + *p = x + return p +} +func (x TraceEvent_Type) String() string { + return proto.EnumName(TraceEvent_Type_name, int32(x)) +} +func (x *TraceEvent_Type) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TraceEvent_Type_value, data, "TraceEvent_Type") + if err != nil { + return err + } + *x = TraceEvent_Type(value) + return nil +} +func (TraceEvent_Type) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 0} +} + +type TraceEvent struct { + Type *TraceEvent_Type `protobuf:"varint,1,opt,name=type,enum=pubsub.pb.TraceEvent_Type" json:"type,omitempty"` + PeerID []byte `protobuf:"bytes,2,opt,name=peerID" json:"peerID,omitempty"` + Timestap *uint64 `protobuf:"varint,3,opt,name=timestap" json:"timestap,omitempty"` + PublishMessage *TraceEvent_PublishMessage `protobuf:"bytes,4,opt,name=publishMessage" json:"publishMessage,omitempty"` + RejectMessage *TraceEvent_RejectMessage `protobuf:"bytes,5,opt,name=rejectMessage" json:"rejectMessage,omitempty"` + DuplicateMessage *TraceEvent_DuplicateMessage `protobuf:"bytes,6,opt,name=duplicateMessage" json:"duplicateMessage,omitempty"` + DeliverMessage *TraceEvent_DeliverMessage `protobuf:"bytes,7,opt,name=deliverMessage" json:"deliverMessage,omitempty"` + AddPeer *TraceEvent_AddPeer `protobuf:"bytes,8,opt,name=addPeer" json:"addPeer,omitempty"` + RemovePeer *TraceEvent_RemovePeer `protobuf:"bytes,9,opt,name=removePeer" json:"removePeer,omitempty"` + RecvRPC *TraceEvent_RecvRPC `protobuf:"bytes,10,opt,name=recvRPC" json:"recvRPC,omitempty"` + SendRPC *TraceEvent_SendRPC `protobuf:"bytes,11,opt,name=sendRPC" json:"sendRPC,omitempty"` + DropRPC *TraceEvent_DropRPC `protobuf:"bytes,12,opt,name=dropRPC" json:"dropRPC,omitempty"` + Join *TraceEvent_Join `protobuf:"bytes,13,opt,name=join" json:"join,omitempty"` + Leave *TraceEvent_Leave `protobuf:"bytes,14,opt,name=leave" json:"leave,omitempty"` + Graft *TraceEvent_Graft `protobuf:"bytes,15,opt,name=graft" json:"graft,omitempty"` + Prune *TraceEvent_Prune `protobuf:"bytes,16,opt,name=prune" json:"prune,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent) Reset() { *m = TraceEvent{} } +func (m *TraceEvent) String() string { return proto.CompactTextString(m) } +func (*TraceEvent) ProtoMessage() {} +func (*TraceEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0} +} +func (m *TraceEvent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent.Merge(dst, src) +} +func (m *TraceEvent) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent proto.InternalMessageInfo + +func (m *TraceEvent) GetType() TraceEvent_Type { + if m != nil && m.Type != nil { + return *m.Type + } + return TraceEvent_PUBLISH_MESSAGE +} + +func (m *TraceEvent) GetPeerID() []byte { + if m != nil { + return m.PeerID + } + return nil +} + +func (m *TraceEvent) GetTimestap() uint64 { + if m != nil && m.Timestap != nil { + return *m.Timestap + } + return 0 +} + +func (m *TraceEvent) GetPublishMessage() *TraceEvent_PublishMessage { + if m != nil { + return m.PublishMessage + } + return nil +} + +func (m *TraceEvent) GetRejectMessage() *TraceEvent_RejectMessage { + if m != nil { + return m.RejectMessage + } + return nil +} + +func (m *TraceEvent) GetDuplicateMessage() *TraceEvent_DuplicateMessage { + if m != nil { + return m.DuplicateMessage + } + return nil +} + +func (m *TraceEvent) GetDeliverMessage() *TraceEvent_DeliverMessage { + if m != nil { + return m.DeliverMessage + } + return nil +} + +func (m *TraceEvent) GetAddPeer() *TraceEvent_AddPeer { + if m != nil { + return m.AddPeer + } + return nil +} + +func (m *TraceEvent) GetRemovePeer() *TraceEvent_RemovePeer { + if m != nil { + return m.RemovePeer + } + return nil +} + +func (m *TraceEvent) GetRecvRPC() *TraceEvent_RecvRPC { + if m != nil { + return m.RecvRPC + } + return nil +} + +func (m *TraceEvent) GetSendRPC() *TraceEvent_SendRPC { + if m != nil { + return m.SendRPC + } + return nil +} + +func (m *TraceEvent) GetDropRPC() *TraceEvent_DropRPC { + if m != nil { + return m.DropRPC + } + return nil +} + +func (m *TraceEvent) GetJoin() *TraceEvent_Join { + if m != nil { + return m.Join + } + return nil +} + +func (m *TraceEvent) GetLeave() *TraceEvent_Leave { + if m != nil { + return m.Leave + } + return nil +} + +func (m *TraceEvent) GetGraft() *TraceEvent_Graft { + if m != nil { + return m.Graft + } + return nil +} + +func (m *TraceEvent) GetPrune() *TraceEvent_Prune { + if m != nil { + return m.Prune + } + return nil +} + +type TraceEvent_PublishMessage struct { + MessageID []byte `protobuf:"bytes,1,opt,name=messageID" json:"messageID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_PublishMessage) Reset() { *m = TraceEvent_PublishMessage{} } +func (m *TraceEvent_PublishMessage) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_PublishMessage) ProtoMessage() {} +func (*TraceEvent_PublishMessage) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 0} +} +func (m *TraceEvent_PublishMessage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_PublishMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_PublishMessage.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_PublishMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_PublishMessage.Merge(dst, src) +} +func (m *TraceEvent_PublishMessage) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_PublishMessage) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_PublishMessage.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_PublishMessage proto.InternalMessageInfo + +func (m *TraceEvent_PublishMessage) GetMessageID() []byte { + if m != nil { + return m.MessageID + } + return nil +} + +type TraceEvent_RejectMessage struct { + MessageID []byte `protobuf:"bytes,1,opt,name=messageID" json:"messageID,omitempty"` + ReceivedFrom []byte `protobuf:"bytes,2,opt,name=receivedFrom" json:"receivedFrom,omitempty"` + Reason *string `protobuf:"bytes,3,opt,name=reason" json:"reason,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_RejectMessage) Reset() { *m = TraceEvent_RejectMessage{} } +func (m *TraceEvent_RejectMessage) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_RejectMessage) ProtoMessage() {} +func (*TraceEvent_RejectMessage) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 1} +} +func (m *TraceEvent_RejectMessage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_RejectMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_RejectMessage.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_RejectMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_RejectMessage.Merge(dst, src) +} +func (m *TraceEvent_RejectMessage) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_RejectMessage) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_RejectMessage.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_RejectMessage proto.InternalMessageInfo + +func (m *TraceEvent_RejectMessage) GetMessageID() []byte { + if m != nil { + return m.MessageID + } + return nil +} + +func (m *TraceEvent_RejectMessage) GetReceivedFrom() []byte { + if m != nil { + return m.ReceivedFrom + } + return nil +} + +func (m *TraceEvent_RejectMessage) GetReason() string { + if m != nil && m.Reason != nil { + return *m.Reason + } + return "" +} + +type TraceEvent_DuplicateMessage struct { + MessageID []byte `protobuf:"bytes,1,opt,name=messageID" json:"messageID,omitempty"` + ReceivedFrom []byte `protobuf:"bytes,2,opt,name=receivedFrom" json:"receivedFrom,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_DuplicateMessage) Reset() { *m = TraceEvent_DuplicateMessage{} } +func (m *TraceEvent_DuplicateMessage) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_DuplicateMessage) ProtoMessage() {} +func (*TraceEvent_DuplicateMessage) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 2} +} +func (m *TraceEvent_DuplicateMessage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_DuplicateMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_DuplicateMessage.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_DuplicateMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_DuplicateMessage.Merge(dst, src) +} +func (m *TraceEvent_DuplicateMessage) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_DuplicateMessage) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_DuplicateMessage.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_DuplicateMessage proto.InternalMessageInfo + +func (m *TraceEvent_DuplicateMessage) GetMessageID() []byte { + if m != nil { + return m.MessageID + } + return nil +} + +func (m *TraceEvent_DuplicateMessage) GetReceivedFrom() []byte { + if m != nil { + return m.ReceivedFrom + } + return nil +} + +type TraceEvent_DeliverMessage struct { + MessageID []byte `protobuf:"bytes,1,opt,name=messageID" json:"messageID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_DeliverMessage) Reset() { *m = TraceEvent_DeliverMessage{} } +func (m *TraceEvent_DeliverMessage) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_DeliverMessage) ProtoMessage() {} +func (*TraceEvent_DeliverMessage) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 3} +} +func (m *TraceEvent_DeliverMessage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_DeliverMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_DeliverMessage.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_DeliverMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_DeliverMessage.Merge(dst, src) +} +func (m *TraceEvent_DeliverMessage) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_DeliverMessage) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_DeliverMessage.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_DeliverMessage proto.InternalMessageInfo + +func (m *TraceEvent_DeliverMessage) GetMessageID() []byte { + if m != nil { + return m.MessageID + } + return nil +} + +type TraceEvent_AddPeer struct { + PeerID []byte `protobuf:"bytes,1,opt,name=peerID" json:"peerID,omitempty"` + Proto *string `protobuf:"bytes,2,opt,name=proto" json:"proto,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_AddPeer) Reset() { *m = TraceEvent_AddPeer{} } +func (m *TraceEvent_AddPeer) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_AddPeer) ProtoMessage() {} +func (*TraceEvent_AddPeer) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 4} +} +func (m *TraceEvent_AddPeer) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_AddPeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_AddPeer.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_AddPeer) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_AddPeer.Merge(dst, src) +} +func (m *TraceEvent_AddPeer) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_AddPeer) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_AddPeer.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_AddPeer proto.InternalMessageInfo + +func (m *TraceEvent_AddPeer) GetPeerID() []byte { + if m != nil { + return m.PeerID + } + return nil +} + +func (m *TraceEvent_AddPeer) GetProto() string { + if m != nil && m.Proto != nil { + return *m.Proto + } + return "" +} + +type TraceEvent_RemovePeer struct { + PeerID []byte `protobuf:"bytes,1,opt,name=peerID" json:"peerID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_RemovePeer) Reset() { *m = TraceEvent_RemovePeer{} } +func (m *TraceEvent_RemovePeer) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_RemovePeer) ProtoMessage() {} +func (*TraceEvent_RemovePeer) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 5} +} +func (m *TraceEvent_RemovePeer) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_RemovePeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_RemovePeer.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_RemovePeer) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_RemovePeer.Merge(dst, src) +} +func (m *TraceEvent_RemovePeer) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_RemovePeer) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_RemovePeer.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_RemovePeer proto.InternalMessageInfo + +func (m *TraceEvent_RemovePeer) GetPeerID() []byte { + if m != nil { + return m.PeerID + } + return nil +} + +type TraceEvent_RecvRPC struct { + ReceivedFrom []byte `protobuf:"bytes,1,opt,name=receivedFrom" json:"receivedFrom,omitempty"` + Meta *TraceEvent_RPCMeta `protobuf:"bytes,2,opt,name=meta" json:"meta,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_RecvRPC) Reset() { *m = TraceEvent_RecvRPC{} } +func (m *TraceEvent_RecvRPC) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_RecvRPC) ProtoMessage() {} +func (*TraceEvent_RecvRPC) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 6} +} +func (m *TraceEvent_RecvRPC) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_RecvRPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_RecvRPC.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_RecvRPC) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_RecvRPC.Merge(dst, src) +} +func (m *TraceEvent_RecvRPC) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_RecvRPC) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_RecvRPC.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_RecvRPC proto.InternalMessageInfo + +func (m *TraceEvent_RecvRPC) GetReceivedFrom() []byte { + if m != nil { + return m.ReceivedFrom + } + return nil +} + +func (m *TraceEvent_RecvRPC) GetMeta() *TraceEvent_RPCMeta { + if m != nil { + return m.Meta + } + return nil +} + +type TraceEvent_SendRPC struct { + SendTo []byte `protobuf:"bytes,1,opt,name=sendTo" json:"sendTo,omitempty"` + Meta *TraceEvent_RPCMeta `protobuf:"bytes,2,opt,name=meta" json:"meta,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_SendRPC) Reset() { *m = TraceEvent_SendRPC{} } +func (m *TraceEvent_SendRPC) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_SendRPC) ProtoMessage() {} +func (*TraceEvent_SendRPC) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 7} +} +func (m *TraceEvent_SendRPC) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_SendRPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_SendRPC.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_SendRPC) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_SendRPC.Merge(dst, src) +} +func (m *TraceEvent_SendRPC) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_SendRPC) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_SendRPC.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_SendRPC proto.InternalMessageInfo + +func (m *TraceEvent_SendRPC) GetSendTo() []byte { + if m != nil { + return m.SendTo + } + return nil +} + +func (m *TraceEvent_SendRPC) GetMeta() *TraceEvent_RPCMeta { + if m != nil { + return m.Meta + } + return nil +} + +type TraceEvent_DropRPC struct { + SendTo []byte `protobuf:"bytes,1,opt,name=sendTo" json:"sendTo,omitempty"` + Meta *TraceEvent_RPCMeta `protobuf:"bytes,2,opt,name=meta" json:"meta,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_DropRPC) Reset() { *m = TraceEvent_DropRPC{} } +func (m *TraceEvent_DropRPC) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_DropRPC) ProtoMessage() {} +func (*TraceEvent_DropRPC) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 8} +} +func (m *TraceEvent_DropRPC) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_DropRPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_DropRPC.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_DropRPC) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_DropRPC.Merge(dst, src) +} +func (m *TraceEvent_DropRPC) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_DropRPC) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_DropRPC.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_DropRPC proto.InternalMessageInfo + +func (m *TraceEvent_DropRPC) GetSendTo() []byte { + if m != nil { + return m.SendTo + } + return nil +} + +func (m *TraceEvent_DropRPC) GetMeta() *TraceEvent_RPCMeta { + if m != nil { + return m.Meta + } + return nil +} + +type TraceEvent_Join struct { + Topic *string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_Join) Reset() { *m = TraceEvent_Join{} } +func (m *TraceEvent_Join) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_Join) ProtoMessage() {} +func (*TraceEvent_Join) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 9} +} +func (m *TraceEvent_Join) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_Join) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_Join.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_Join) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_Join.Merge(dst, src) +} +func (m *TraceEvent_Join) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_Join) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_Join.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_Join proto.InternalMessageInfo + +func (m *TraceEvent_Join) GetTopic() string { + if m != nil && m.Topic != nil { + return *m.Topic + } + return "" +} + +type TraceEvent_Leave struct { + Topic *string `protobuf:"bytes,2,opt,name=topic" json:"topic,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_Leave) Reset() { *m = TraceEvent_Leave{} } +func (m *TraceEvent_Leave) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_Leave) ProtoMessage() {} +func (*TraceEvent_Leave) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 10} +} +func (m *TraceEvent_Leave) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_Leave) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_Leave.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_Leave) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_Leave.Merge(dst, src) +} +func (m *TraceEvent_Leave) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_Leave) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_Leave.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_Leave proto.InternalMessageInfo + +func (m *TraceEvent_Leave) GetTopic() string { + if m != nil && m.Topic != nil { + return *m.Topic + } + return "" +} + +type TraceEvent_Graft struct { + PeerID []byte `protobuf:"bytes,1,opt,name=peerID" json:"peerID,omitempty"` + Topic *string `protobuf:"bytes,2,opt,name=topic" json:"topic,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_Graft) Reset() { *m = TraceEvent_Graft{} } +func (m *TraceEvent_Graft) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_Graft) ProtoMessage() {} +func (*TraceEvent_Graft) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 11} +} +func (m *TraceEvent_Graft) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_Graft) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_Graft.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_Graft) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_Graft.Merge(dst, src) +} +func (m *TraceEvent_Graft) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_Graft) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_Graft.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_Graft proto.InternalMessageInfo + +func (m *TraceEvent_Graft) GetPeerID() []byte { + if m != nil { + return m.PeerID + } + return nil +} + +func (m *TraceEvent_Graft) GetTopic() string { + if m != nil && m.Topic != nil { + return *m.Topic + } + return "" +} + +type TraceEvent_Prune struct { + PeerID []byte `protobuf:"bytes,1,opt,name=peerID" json:"peerID,omitempty"` + Topic *string `protobuf:"bytes,2,opt,name=topic" json:"topic,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_Prune) Reset() { *m = TraceEvent_Prune{} } +func (m *TraceEvent_Prune) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_Prune) ProtoMessage() {} +func (*TraceEvent_Prune) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 12} +} +func (m *TraceEvent_Prune) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_Prune) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_Prune.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_Prune) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_Prune.Merge(dst, src) +} +func (m *TraceEvent_Prune) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_Prune) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_Prune.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_Prune proto.InternalMessageInfo + +func (m *TraceEvent_Prune) GetPeerID() []byte { + if m != nil { + return m.PeerID + } + return nil +} + +func (m *TraceEvent_Prune) GetTopic() string { + if m != nil && m.Topic != nil { + return *m.Topic + } + return "" +} + +type TraceEvent_RPCMeta struct { + MessageIDs [][]byte `protobuf:"bytes,1,rep,name=messageIDs" json:"messageIDs,omitempty"` + SubMeta []*TraceEvent_SubMeta `protobuf:"bytes,2,rep,name=subMeta" json:"subMeta,omitempty"` + ControlMeta *TraceEvent_ControlMeta `protobuf:"bytes,3,opt,name=controlMeta" json:"controlMeta,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_RPCMeta) Reset() { *m = TraceEvent_RPCMeta{} } +func (m *TraceEvent_RPCMeta) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_RPCMeta) ProtoMessage() {} +func (*TraceEvent_RPCMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 13} +} +func (m *TraceEvent_RPCMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_RPCMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_RPCMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_RPCMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_RPCMeta.Merge(dst, src) +} +func (m *TraceEvent_RPCMeta) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_RPCMeta) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_RPCMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_RPCMeta proto.InternalMessageInfo + +func (m *TraceEvent_RPCMeta) GetMessageIDs() [][]byte { + if m != nil { + return m.MessageIDs + } + return nil +} + +func (m *TraceEvent_RPCMeta) GetSubMeta() []*TraceEvent_SubMeta { + if m != nil { + return m.SubMeta + } + return nil +} + +func (m *TraceEvent_RPCMeta) GetControlMeta() *TraceEvent_ControlMeta { + if m != nil { + return m.ControlMeta + } + return nil +} + +type TraceEvent_SubMeta struct { + Subscribe *bool `protobuf:"varint,1,opt,name=subscribe" json:"subscribe,omitempty"` + Topic *string `protobuf:"bytes,2,opt,name=topic" json:"topic,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_SubMeta) Reset() { *m = TraceEvent_SubMeta{} } +func (m *TraceEvent_SubMeta) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_SubMeta) ProtoMessage() {} +func (*TraceEvent_SubMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 14} +} +func (m *TraceEvent_SubMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_SubMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_SubMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_SubMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_SubMeta.Merge(dst, src) +} +func (m *TraceEvent_SubMeta) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_SubMeta) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_SubMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_SubMeta proto.InternalMessageInfo + +func (m *TraceEvent_SubMeta) GetSubscribe() bool { + if m != nil && m.Subscribe != nil { + return *m.Subscribe + } + return false +} + +func (m *TraceEvent_SubMeta) GetTopic() string { + if m != nil && m.Topic != nil { + return *m.Topic + } + return "" +} + +type TraceEvent_ControlMeta struct { + Ihave []*TraceEvent_ControlIHaveMeta `protobuf:"bytes,1,rep,name=ihave" json:"ihave,omitempty"` + Iwant []*TraceEvent_ControlIWantMeta `protobuf:"bytes,2,rep,name=iwant" json:"iwant,omitempty"` + Graft []*TraceEvent_ControlGraftMeta `protobuf:"bytes,3,rep,name=graft" json:"graft,omitempty"` + Prune []*TraceEvent_ControlPruneMeta `protobuf:"bytes,4,rep,name=prune" json:"prune,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_ControlMeta) Reset() { *m = TraceEvent_ControlMeta{} } +func (m *TraceEvent_ControlMeta) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_ControlMeta) ProtoMessage() {} +func (*TraceEvent_ControlMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 15} +} +func (m *TraceEvent_ControlMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_ControlMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_ControlMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_ControlMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlMeta.Merge(dst, src) +} +func (m *TraceEvent_ControlMeta) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_ControlMeta) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_ControlMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_ControlMeta proto.InternalMessageInfo + +func (m *TraceEvent_ControlMeta) GetIhave() []*TraceEvent_ControlIHaveMeta { + if m != nil { + return m.Ihave + } + return nil +} + +func (m *TraceEvent_ControlMeta) GetIwant() []*TraceEvent_ControlIWantMeta { + if m != nil { + return m.Iwant + } + return nil +} + +func (m *TraceEvent_ControlMeta) GetGraft() []*TraceEvent_ControlGraftMeta { + if m != nil { + return m.Graft + } + return nil +} + +func (m *TraceEvent_ControlMeta) GetPrune() []*TraceEvent_ControlPruneMeta { + if m != nil { + return m.Prune + } + return nil +} + +type TraceEvent_ControlIHaveMeta struct { + Topic *string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"` + MessageIDs [][]byte `protobuf:"bytes,2,rep,name=messageIDs" json:"messageIDs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_ControlIHaveMeta) Reset() { *m = TraceEvent_ControlIHaveMeta{} } +func (m *TraceEvent_ControlIHaveMeta) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_ControlIHaveMeta) ProtoMessage() {} +func (*TraceEvent_ControlIHaveMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 16} +} +func (m *TraceEvent_ControlIHaveMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_ControlIHaveMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_ControlIHaveMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_ControlIHaveMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlIHaveMeta.Merge(dst, src) +} +func (m *TraceEvent_ControlIHaveMeta) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_ControlIHaveMeta) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_ControlIHaveMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_ControlIHaveMeta proto.InternalMessageInfo + +func (m *TraceEvent_ControlIHaveMeta) GetTopic() string { + if m != nil && m.Topic != nil { + return *m.Topic + } + return "" +} + +func (m *TraceEvent_ControlIHaveMeta) GetMessageIDs() [][]byte { + if m != nil { + return m.MessageIDs + } + return nil +} + +type TraceEvent_ControlIWantMeta struct { + MessageIDs [][]byte `protobuf:"bytes,1,rep,name=messageIDs" json:"messageIDs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_ControlIWantMeta) Reset() { *m = TraceEvent_ControlIWantMeta{} } +func (m *TraceEvent_ControlIWantMeta) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_ControlIWantMeta) ProtoMessage() {} +func (*TraceEvent_ControlIWantMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 17} +} +func (m *TraceEvent_ControlIWantMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_ControlIWantMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_ControlIWantMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_ControlIWantMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlIWantMeta.Merge(dst, src) +} +func (m *TraceEvent_ControlIWantMeta) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_ControlIWantMeta) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_ControlIWantMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_ControlIWantMeta proto.InternalMessageInfo + +func (m *TraceEvent_ControlIWantMeta) GetMessageIDs() [][]byte { + if m != nil { + return m.MessageIDs + } + return nil +} + +type TraceEvent_ControlGraftMeta struct { + Topic *string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_ControlGraftMeta) Reset() { *m = TraceEvent_ControlGraftMeta{} } +func (m *TraceEvent_ControlGraftMeta) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_ControlGraftMeta) ProtoMessage() {} +func (*TraceEvent_ControlGraftMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 18} +} +func (m *TraceEvent_ControlGraftMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_ControlGraftMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_ControlGraftMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_ControlGraftMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlGraftMeta.Merge(dst, src) +} +func (m *TraceEvent_ControlGraftMeta) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_ControlGraftMeta) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_ControlGraftMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_ControlGraftMeta proto.InternalMessageInfo + +func (m *TraceEvent_ControlGraftMeta) GetTopic() string { + if m != nil && m.Topic != nil { + return *m.Topic + } + return "" +} + +type TraceEvent_ControlPruneMeta struct { + Topic *string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_ControlPruneMeta) Reset() { *m = TraceEvent_ControlPruneMeta{} } +func (m *TraceEvent_ControlPruneMeta) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_ControlPruneMeta) ProtoMessage() {} +func (*TraceEvent_ControlPruneMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_c3fa177daeafa133, []int{0, 19} +} +func (m *TraceEvent_ControlPruneMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_ControlPruneMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_ControlPruneMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_ControlPruneMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlPruneMeta.Merge(dst, src) +} +func (m *TraceEvent_ControlPruneMeta) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_ControlPruneMeta) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_ControlPruneMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_ControlPruneMeta proto.InternalMessageInfo + +func (m *TraceEvent_ControlPruneMeta) GetTopic() string { + if m != nil && m.Topic != nil { + return *m.Topic + } + return "" +} + +func init() { + proto.RegisterType((*TraceEvent)(nil), "pubsub.pb.TraceEvent") + proto.RegisterType((*TraceEvent_PublishMessage)(nil), "pubsub.pb.TraceEvent.PublishMessage") + proto.RegisterType((*TraceEvent_RejectMessage)(nil), "pubsub.pb.TraceEvent.RejectMessage") + proto.RegisterType((*TraceEvent_DuplicateMessage)(nil), "pubsub.pb.TraceEvent.DuplicateMessage") + proto.RegisterType((*TraceEvent_DeliverMessage)(nil), "pubsub.pb.TraceEvent.DeliverMessage") + proto.RegisterType((*TraceEvent_AddPeer)(nil), "pubsub.pb.TraceEvent.AddPeer") + proto.RegisterType((*TraceEvent_RemovePeer)(nil), "pubsub.pb.TraceEvent.RemovePeer") + proto.RegisterType((*TraceEvent_RecvRPC)(nil), "pubsub.pb.TraceEvent.RecvRPC") + proto.RegisterType((*TraceEvent_SendRPC)(nil), "pubsub.pb.TraceEvent.SendRPC") + proto.RegisterType((*TraceEvent_DropRPC)(nil), "pubsub.pb.TraceEvent.DropRPC") + proto.RegisterType((*TraceEvent_Join)(nil), "pubsub.pb.TraceEvent.Join") + proto.RegisterType((*TraceEvent_Leave)(nil), "pubsub.pb.TraceEvent.Leave") + proto.RegisterType((*TraceEvent_Graft)(nil), "pubsub.pb.TraceEvent.Graft") + proto.RegisterType((*TraceEvent_Prune)(nil), "pubsub.pb.TraceEvent.Prune") + proto.RegisterType((*TraceEvent_RPCMeta)(nil), "pubsub.pb.TraceEvent.RPCMeta") + proto.RegisterType((*TraceEvent_SubMeta)(nil), "pubsub.pb.TraceEvent.SubMeta") + proto.RegisterType((*TraceEvent_ControlMeta)(nil), "pubsub.pb.TraceEvent.ControlMeta") + proto.RegisterType((*TraceEvent_ControlIHaveMeta)(nil), "pubsub.pb.TraceEvent.ControlIHaveMeta") + proto.RegisterType((*TraceEvent_ControlIWantMeta)(nil), "pubsub.pb.TraceEvent.ControlIWantMeta") + proto.RegisterType((*TraceEvent_ControlGraftMeta)(nil), "pubsub.pb.TraceEvent.ControlGraftMeta") + proto.RegisterType((*TraceEvent_ControlPruneMeta)(nil), "pubsub.pb.TraceEvent.ControlPruneMeta") + proto.RegisterEnum("pubsub.pb.TraceEvent_Type", TraceEvent_Type_name, TraceEvent_Type_value) +} +func (m *TraceEvent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Type != nil { + dAtA[i] = 0x8 + i++ + i = encodeVarintTrace(dAtA, i, uint64(*m.Type)) + } + if m.PeerID != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.PeerID))) + i += copy(dAtA[i:], m.PeerID) + } + if m.Timestap != nil { + dAtA[i] = 0x18 + i++ + i = encodeVarintTrace(dAtA, i, uint64(*m.Timestap)) + } + if m.PublishMessage != nil { + dAtA[i] = 0x22 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.PublishMessage.Size())) + n1, err := m.PublishMessage.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.RejectMessage != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.RejectMessage.Size())) + n2, err := m.RejectMessage.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n2 + } + if m.DuplicateMessage != nil { + dAtA[i] = 0x32 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.DuplicateMessage.Size())) + n3, err := m.DuplicateMessage.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if m.DeliverMessage != nil { + dAtA[i] = 0x3a + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.DeliverMessage.Size())) + n4, err := m.DeliverMessage.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n4 + } + if m.AddPeer != nil { + dAtA[i] = 0x42 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.AddPeer.Size())) + n5, err := m.AddPeer.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n5 + } + if m.RemovePeer != nil { + dAtA[i] = 0x4a + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.RemovePeer.Size())) + n6, err := m.RemovePeer.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n6 + } + if m.RecvRPC != nil { + dAtA[i] = 0x52 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.RecvRPC.Size())) + n7, err := m.RecvRPC.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n7 + } + if m.SendRPC != nil { + dAtA[i] = 0x5a + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.SendRPC.Size())) + n8, err := m.SendRPC.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n8 + } + if m.DropRPC != nil { + dAtA[i] = 0x62 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.DropRPC.Size())) + n9, err := m.DropRPC.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n9 + } + if m.Join != nil { + dAtA[i] = 0x6a + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.Join.Size())) + n10, err := m.Join.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 + } + if m.Leave != nil { + dAtA[i] = 0x72 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.Leave.Size())) + n11, err := m.Leave.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n11 + } + if m.Graft != nil { + dAtA[i] = 0x7a + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.Graft.Size())) + n12, err := m.Graft.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n12 + } + if m.Prune != nil { + dAtA[i] = 0x82 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.Prune.Size())) + n13, err := m.Prune.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n13 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_PublishMessage) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_PublishMessage) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MessageID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.MessageID))) + i += copy(dAtA[i:], m.MessageID) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_RejectMessage) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_RejectMessage) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MessageID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.MessageID))) + i += copy(dAtA[i:], m.MessageID) + } + if m.ReceivedFrom != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.ReceivedFrom))) + i += copy(dAtA[i:], m.ReceivedFrom) + } + if m.Reason != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Reason))) + i += copy(dAtA[i:], *m.Reason) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_DuplicateMessage) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_DuplicateMessage) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MessageID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.MessageID))) + i += copy(dAtA[i:], m.MessageID) + } + if m.ReceivedFrom != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.ReceivedFrom))) + i += copy(dAtA[i:], m.ReceivedFrom) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_DeliverMessage) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_DeliverMessage) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MessageID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.MessageID))) + i += copy(dAtA[i:], m.MessageID) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_AddPeer) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_AddPeer) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.PeerID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.PeerID))) + i += copy(dAtA[i:], m.PeerID) + } + if m.Proto != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Proto))) + i += copy(dAtA[i:], *m.Proto) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_RemovePeer) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_RemovePeer) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.PeerID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.PeerID))) + i += copy(dAtA[i:], m.PeerID) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_RecvRPC) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_RecvRPC) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.ReceivedFrom != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.ReceivedFrom))) + i += copy(dAtA[i:], m.ReceivedFrom) + } + if m.Meta != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.Meta.Size())) + n14, err := m.Meta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n14 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_SendRPC) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_SendRPC) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.SendTo != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.SendTo))) + i += copy(dAtA[i:], m.SendTo) + } + if m.Meta != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.Meta.Size())) + n15, err := m.Meta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n15 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_DropRPC) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_DropRPC) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.SendTo != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.SendTo))) + i += copy(dAtA[i:], m.SendTo) + } + if m.Meta != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.Meta.Size())) + n16, err := m.Meta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n16 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_Join) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_Join) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Topic != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Topic))) + i += copy(dAtA[i:], *m.Topic) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_Leave) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_Leave) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Topic != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Topic))) + i += copy(dAtA[i:], *m.Topic) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_Graft) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_Graft) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.PeerID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.PeerID))) + i += copy(dAtA[i:], m.PeerID) + } + if m.Topic != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Topic))) + i += copy(dAtA[i:], *m.Topic) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_Prune) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_Prune) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.PeerID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.PeerID))) + i += copy(dAtA[i:], m.PeerID) + } + if m.Topic != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Topic))) + i += copy(dAtA[i:], *m.Topic) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_RPCMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_RPCMeta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.MessageIDs) > 0 { + for _, b := range m.MessageIDs { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(b))) + i += copy(dAtA[i:], b) + } + } + if len(m.SubMeta) > 0 { + for _, msg := range m.SubMeta { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.ControlMeta != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintTrace(dAtA, i, uint64(m.ControlMeta.Size())) + n17, err := m.ControlMeta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n17 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_SubMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_SubMeta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Subscribe != nil { + dAtA[i] = 0x8 + i++ + if *m.Subscribe { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.Topic != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Topic))) + i += copy(dAtA[i:], *m.Topic) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_ControlMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_ControlMeta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Ihave) > 0 { + for _, msg := range m.Ihave { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Iwant) > 0 { + for _, msg := range m.Iwant { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Graft) > 0 { + for _, msg := range m.Graft { + dAtA[i] = 0x1a + i++ + i = encodeVarintTrace(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Prune) > 0 { + for _, msg := range m.Prune { + dAtA[i] = 0x22 + i++ + i = encodeVarintTrace(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_ControlIHaveMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_ControlIHaveMeta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Topic != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Topic))) + i += copy(dAtA[i:], *m.Topic) + } + if len(m.MessageIDs) > 0 { + for _, b := range m.MessageIDs { + dAtA[i] = 0x12 + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(b))) + i += copy(dAtA[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_ControlIWantMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_ControlIWantMeta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.MessageIDs) > 0 { + for _, b := range m.MessageIDs { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(b))) + i += copy(dAtA[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_ControlGraftMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_ControlGraftMeta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Topic != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Topic))) + i += copy(dAtA[i:], *m.Topic) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TraceEvent_ControlPruneMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_ControlPruneMeta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Topic != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(*m.Topic))) + i += copy(dAtA[i:], *m.Topic) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeVarintTrace(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *TraceEvent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Type != nil { + n += 1 + sovTrace(uint64(*m.Type)) + } + if m.PeerID != nil { + l = len(m.PeerID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.Timestap != nil { + n += 1 + sovTrace(uint64(*m.Timestap)) + } + if m.PublishMessage != nil { + l = m.PublishMessage.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.RejectMessage != nil { + l = m.RejectMessage.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.DuplicateMessage != nil { + l = m.DuplicateMessage.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.DeliverMessage != nil { + l = m.DeliverMessage.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.AddPeer != nil { + l = m.AddPeer.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.RemovePeer != nil { + l = m.RemovePeer.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.RecvRPC != nil { + l = m.RecvRPC.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.SendRPC != nil { + l = m.SendRPC.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.DropRPC != nil { + l = m.DropRPC.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.Join != nil { + l = m.Join.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.Leave != nil { + l = m.Leave.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.Graft != nil { + l = m.Graft.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.Prune != nil { + l = m.Prune.Size() + n += 2 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_PublishMessage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MessageID != nil { + l = len(m.MessageID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_RejectMessage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MessageID != nil { + l = len(m.MessageID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.ReceivedFrom != nil { + l = len(m.ReceivedFrom) + n += 1 + l + sovTrace(uint64(l)) + } + if m.Reason != nil { + l = len(*m.Reason) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_DuplicateMessage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MessageID != nil { + l = len(m.MessageID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.ReceivedFrom != nil { + l = len(m.ReceivedFrom) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_DeliverMessage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MessageID != nil { + l = len(m.MessageID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_AddPeer) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerID != nil { + l = len(m.PeerID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.Proto != nil { + l = len(*m.Proto) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_RemovePeer) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerID != nil { + l = len(m.PeerID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_RecvRPC) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ReceivedFrom != nil { + l = len(m.ReceivedFrom) + n += 1 + l + sovTrace(uint64(l)) + } + if m.Meta != nil { + l = m.Meta.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_SendRPC) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SendTo != nil { + l = len(m.SendTo) + n += 1 + l + sovTrace(uint64(l)) + } + if m.Meta != nil { + l = m.Meta.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_DropRPC) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SendTo != nil { + l = len(m.SendTo) + n += 1 + l + sovTrace(uint64(l)) + } + if m.Meta != nil { + l = m.Meta.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_Join) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Topic != nil { + l = len(*m.Topic) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_Leave) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Topic != nil { + l = len(*m.Topic) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_Graft) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerID != nil { + l = len(m.PeerID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.Topic != nil { + l = len(*m.Topic) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_Prune) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerID != nil { + l = len(m.PeerID) + n += 1 + l + sovTrace(uint64(l)) + } + if m.Topic != nil { + l = len(*m.Topic) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_RPCMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.MessageIDs) > 0 { + for _, b := range m.MessageIDs { + l = len(b) + n += 1 + l + sovTrace(uint64(l)) + } + } + if len(m.SubMeta) > 0 { + for _, e := range m.SubMeta { + l = e.Size() + n += 1 + l + sovTrace(uint64(l)) + } + } + if m.ControlMeta != nil { + l = m.ControlMeta.Size() + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_SubMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Subscribe != nil { + n += 2 + } + if m.Topic != nil { + l = len(*m.Topic) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_ControlMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Ihave) > 0 { + for _, e := range m.Ihave { + l = e.Size() + n += 1 + l + sovTrace(uint64(l)) + } + } + if len(m.Iwant) > 0 { + for _, e := range m.Iwant { + l = e.Size() + n += 1 + l + sovTrace(uint64(l)) + } + } + if len(m.Graft) > 0 { + for _, e := range m.Graft { + l = e.Size() + n += 1 + l + sovTrace(uint64(l)) + } + } + if len(m.Prune) > 0 { + for _, e := range m.Prune { + l = e.Size() + n += 1 + l + sovTrace(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_ControlIHaveMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Topic != nil { + l = len(*m.Topic) + n += 1 + l + sovTrace(uint64(l)) + } + if len(m.MessageIDs) > 0 { + for _, b := range m.MessageIDs { + l = len(b) + n += 1 + l + sovTrace(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_ControlIWantMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.MessageIDs) > 0 { + for _, b := range m.MessageIDs { + l = len(b) + n += 1 + l + sovTrace(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_ControlGraftMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Topic != nil { + l = len(*m.Topic) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TraceEvent_ControlPruneMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Topic != nil { + l = len(*m.Topic) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovTrace(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozTrace(x uint64) (n int) { + return sovTrace(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *TraceEvent) 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 ErrIntOverflowTrace + } + 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: TraceEvent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TraceEvent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var v TraceEvent_Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (TraceEvent_Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Type = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerID = append(m.PeerID[:0], dAtA[iNdEx:postIndex]...) + if m.PeerID == nil { + m.PeerID = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestap", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Timestap = &v + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PublishMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PublishMessage == nil { + m.PublishMessage = &TraceEvent_PublishMessage{} + } + if err := m.PublishMessage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RejectMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RejectMessage == nil { + m.RejectMessage = &TraceEvent_RejectMessage{} + } + if err := m.RejectMessage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DuplicateMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DuplicateMessage == nil { + m.DuplicateMessage = &TraceEvent_DuplicateMessage{} + } + if err := m.DuplicateMessage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeliverMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DeliverMessage == nil { + m.DeliverMessage = &TraceEvent_DeliverMessage{} + } + if err := m.DeliverMessage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AddPeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AddPeer == nil { + m.AddPeer = &TraceEvent_AddPeer{} + } + if err := m.AddPeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemovePeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemovePeer == nil { + m.RemovePeer = &TraceEvent_RemovePeer{} + } + if err := m.RemovePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RecvRPC", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RecvRPC == nil { + m.RecvRPC = &TraceEvent_RecvRPC{} + } + if err := m.RecvRPC.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SendRPC", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SendRPC == nil { + m.SendRPC = &TraceEvent_SendRPC{} + } + if err := m.SendRPC.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DropRPC", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DropRPC == nil { + m.DropRPC = &TraceEvent_DropRPC{} + } + if err := m.DropRPC.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Join", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Join == nil { + m.Join = &TraceEvent_Join{} + } + if err := m.Join.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leave", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leave == nil { + m.Leave = &TraceEvent_Leave{} + } + if err := m.Leave.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graft", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Graft == nil { + m.Graft = &TraceEvent_Graft{} + } + if err := m.Graft.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prune", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Prune == nil { + m.Prune = &TraceEvent_Prune{} + } + if err := m.Prune.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_PublishMessage) 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 ErrIntOverflowTrace + } + 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: PublishMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PublishMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageID = append(m.MessageID[:0], dAtA[iNdEx:postIndex]...) + if m.MessageID == nil { + m.MessageID = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_RejectMessage) 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 ErrIntOverflowTrace + } + 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: RejectMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RejectMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageID = append(m.MessageID[:0], dAtA[iNdEx:postIndex]...) + if m.MessageID == nil { + m.MessageID = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceivedFrom", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceivedFrom = append(m.ReceivedFrom[:0], dAtA[iNdEx:postIndex]...) + if m.ReceivedFrom == nil { + m.ReceivedFrom = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Reason = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_DuplicateMessage) 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 ErrIntOverflowTrace + } + 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: DuplicateMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DuplicateMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageID = append(m.MessageID[:0], dAtA[iNdEx:postIndex]...) + if m.MessageID == nil { + m.MessageID = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceivedFrom", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceivedFrom = append(m.ReceivedFrom[:0], dAtA[iNdEx:postIndex]...) + if m.ReceivedFrom == nil { + m.ReceivedFrom = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_DeliverMessage) 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 ErrIntOverflowTrace + } + 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: DeliverMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeliverMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageID = append(m.MessageID[:0], dAtA[iNdEx:postIndex]...) + if m.MessageID == nil { + m.MessageID = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_AddPeer) 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 ErrIntOverflowTrace + } + 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: AddPeer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AddPeer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerID = append(m.PeerID[:0], dAtA[iNdEx:postIndex]...) + if m.PeerID == nil { + m.PeerID = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Proto = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_RemovePeer) 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 ErrIntOverflowTrace + } + 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: RemovePeer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RemovePeer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerID = append(m.PeerID[:0], dAtA[iNdEx:postIndex]...) + if m.PeerID == nil { + m.PeerID = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_RecvRPC) 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 ErrIntOverflowTrace + } + 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: RecvRPC: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RecvRPC: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceivedFrom", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceivedFrom = append(m.ReceivedFrom[:0], dAtA[iNdEx:postIndex]...) + if m.ReceivedFrom == nil { + m.ReceivedFrom = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Meta == nil { + m.Meta = &TraceEvent_RPCMeta{} + } + if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_SendRPC) 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 ErrIntOverflowTrace + } + 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: SendRPC: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SendRPC: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SendTo", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SendTo = append(m.SendTo[:0], dAtA[iNdEx:postIndex]...) + if m.SendTo == nil { + m.SendTo = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Meta == nil { + m.Meta = &TraceEvent_RPCMeta{} + } + if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_DropRPC) 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 ErrIntOverflowTrace + } + 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: DropRPC: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DropRPC: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SendTo", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SendTo = append(m.SendTo[:0], dAtA[iNdEx:postIndex]...) + if m.SendTo == nil { + m.SendTo = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Meta == nil { + m.Meta = &TraceEvent_RPCMeta{} + } + if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_Join) 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 ErrIntOverflowTrace + } + 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: Join: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Join: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Topic = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_Leave) 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 ErrIntOverflowTrace + } + 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: Leave: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Leave: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Topic = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_Graft) 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 ErrIntOverflowTrace + } + 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: Graft: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Graft: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerID = append(m.PeerID[:0], dAtA[iNdEx:postIndex]...) + if m.PeerID == nil { + m.PeerID = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Topic = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_Prune) 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 ErrIntOverflowTrace + } + 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: Prune: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Prune: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerID = append(m.PeerID[:0], dAtA[iNdEx:postIndex]...) + if m.PeerID == nil { + m.PeerID = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Topic = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_RPCMeta) 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 ErrIntOverflowTrace + } + 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: RPCMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RPCMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIDs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageIDs = append(m.MessageIDs, make([]byte, postIndex-iNdEx)) + copy(m.MessageIDs[len(m.MessageIDs)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SubMeta = append(m.SubMeta, &TraceEvent_SubMeta{}) + if err := m.SubMeta[len(m.SubMeta)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ControlMeta == nil { + m.ControlMeta = &TraceEvent_ControlMeta{} + } + if err := m.ControlMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_SubMeta) 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 ErrIntOverflowTrace + } + 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: SubMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SubMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Subscribe", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Subscribe = &b + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Topic = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_ControlMeta) 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 ErrIntOverflowTrace + } + 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: ControlMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ihave", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ihave = append(m.Ihave, &TraceEvent_ControlIHaveMeta{}) + if err := m.Ihave[len(m.Ihave)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Iwant", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Iwant = append(m.Iwant, &TraceEvent_ControlIWantMeta{}) + if err := m.Iwant[len(m.Iwant)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graft", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graft = append(m.Graft, &TraceEvent_ControlGraftMeta{}) + if err := m.Graft[len(m.Graft)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prune", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Prune = append(m.Prune, &TraceEvent_ControlPruneMeta{}) + if err := m.Prune[len(m.Prune)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_ControlIHaveMeta) 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 ErrIntOverflowTrace + } + 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: ControlIHaveMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlIHaveMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Topic = &s + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIDs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageIDs = append(m.MessageIDs, make([]byte, postIndex-iNdEx)) + copy(m.MessageIDs[len(m.MessageIDs)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_ControlIWantMeta) 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 ErrIntOverflowTrace + } + 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: ControlIWantMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlIWantMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIDs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageIDs = append(m.MessageIDs, make([]byte, postIndex-iNdEx)) + copy(m.MessageIDs[len(m.MessageIDs)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_ControlGraftMeta) 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 ErrIntOverflowTrace + } + 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: ControlGraftMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlGraftMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Topic = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEvent_ControlPruneMeta) 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 ErrIntOverflowTrace + } + 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: ControlPruneMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlPruneMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Topic = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTrace(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTrace + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTrace + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTrace + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthTrace + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTrace + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipTrace(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthTrace = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTrace = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("trace.proto", fileDescriptor_trace_c3fa177daeafa133) } + +var fileDescriptor_trace_c3fa177daeafa133 = []byte{ + // 922 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xd1, 0x8e, 0xda, 0x46, + 0x14, 0x86, 0x6b, 0x30, 0x0b, 0x1c, 0x58, 0xd6, 0x9d, 0xa6, 0x95, 0xe5, 0x26, 0x88, 0x6e, 0xa3, + 0x88, 0x2b, 0xa4, 0xac, 0x54, 0xe5, 0x26, 0x95, 0x4a, 0xf0, 0x64, 0x97, 0x15, 0xec, 0x5a, 0x07, + 0x76, 0x7b, 0xb9, 0x35, 0x30, 0x4d, 0x1c, 0x81, 0x6d, 0xd9, 0x86, 0x2a, 0x0f, 0xd0, 0x67, 0xe9, + 0xab, 0xf4, 0xaa, 0xea, 0x23, 0x54, 0x7b, 0xd3, 0xd7, 0xa8, 0x66, 0xc6, 0x36, 0x98, 0x18, 0x6f, + 0xda, 0xe6, 0xce, 0x67, 0xe6, 0xff, 0xce, 0xcc, 0x99, 0xfd, 0xcf, 0x59, 0xa0, 0x11, 0x05, 0xf6, + 0x9c, 0xf5, 0xfc, 0xc0, 0x8b, 0x3c, 0x52, 0xf7, 0xd7, 0xb3, 0x70, 0x3d, 0xeb, 0xf9, 0xb3, 0xd3, + 0xbf, 0x1f, 0x01, 0x4c, 0xf9, 0x16, 0xdd, 0x30, 0x37, 0x22, 0x3d, 0x50, 0xa3, 0xf7, 0x3e, 0xd3, + 0x95, 0x8e, 0xd2, 0x6d, 0x9d, 0x19, 0xbd, 0x54, 0xd8, 0xdb, 0x8a, 0x7a, 0xd3, 0xf7, 0x3e, 0x43, + 0xa1, 0x23, 0x5f, 0xc1, 0x91, 0xcf, 0x58, 0x30, 0x34, 0xf5, 0x52, 0x47, 0xe9, 0x36, 0x31, 0x8e, + 0x88, 0x01, 0xb5, 0xc8, 0x59, 0xb1, 0x30, 0xb2, 0x7d, 0xbd, 0xdc, 0x51, 0xba, 0x2a, 0xa6, 0x31, + 0x19, 0x41, 0xcb, 0x5f, 0xcf, 0x96, 0x4e, 0xf8, 0x76, 0xcc, 0xc2, 0xd0, 0x7e, 0xc3, 0x74, 0xb5, + 0xa3, 0x74, 0x1b, 0x67, 0x4f, 0xf3, 0x4f, 0xb3, 0x32, 0x5a, 0xdc, 0x63, 0xc9, 0x10, 0x8e, 0x03, + 0xf6, 0x8e, 0xcd, 0xa3, 0x24, 0x59, 0x45, 0x24, 0xfb, 0x36, 0x3f, 0x19, 0xee, 0x4a, 0x31, 0x4b, + 0x12, 0x04, 0x6d, 0xb1, 0xf6, 0x97, 0xce, 0xdc, 0x8e, 0x58, 0x92, 0xed, 0x48, 0x64, 0x7b, 0x96, + 0x9f, 0xcd, 0xdc, 0x53, 0xe3, 0x07, 0x3c, 0x2f, 0x76, 0xc1, 0x96, 0xce, 0x86, 0x05, 0x49, 0xc6, + 0x6a, 0x51, 0xb1, 0x66, 0x46, 0x8b, 0x7b, 0x2c, 0x79, 0x01, 0x55, 0x7b, 0xb1, 0xb0, 0x18, 0x0b, + 0xf4, 0x9a, 0x48, 0xf3, 0x24, 0x3f, 0x4d, 0x5f, 0x8a, 0x30, 0x51, 0x93, 0x1f, 0x00, 0x02, 0xb6, + 0xf2, 0x36, 0x4c, 0xb0, 0x75, 0xc1, 0x76, 0x0e, 0x3d, 0x51, 0xa2, 0xc3, 0x1d, 0x86, 0x1f, 0x1d, + 0xb0, 0xf9, 0x06, 0xad, 0x81, 0x0e, 0x45, 0x47, 0xa3, 0x14, 0x61, 0xa2, 0xe6, 0x60, 0xc8, 0xdc, + 0x05, 0x07, 0x1b, 0x45, 0xe0, 0x44, 0x8a, 0x30, 0x51, 0x73, 0x70, 0x11, 0x78, 0x3e, 0x07, 0x9b, + 0x45, 0xa0, 0x29, 0x45, 0x98, 0xa8, 0xb9, 0x89, 0xdf, 0x79, 0x8e, 0xab, 0x1f, 0x0b, 0xea, 0x80, + 0x89, 0x2f, 0x3d, 0xc7, 0x45, 0xa1, 0x23, 0xcf, 0xa1, 0xb2, 0x64, 0xf6, 0x86, 0xe9, 0x2d, 0x01, + 0x7c, 0x9d, 0x0f, 0x8c, 0xb8, 0x04, 0xa5, 0x92, 0x23, 0x6f, 0x02, 0xfb, 0xe7, 0x48, 0x3f, 0x29, + 0x42, 0xce, 0xb9, 0x04, 0xa5, 0x92, 0x23, 0x7e, 0xb0, 0x76, 0x99, 0xae, 0x15, 0x21, 0x16, 0x97, + 0xa0, 0x54, 0x1a, 0x3d, 0x68, 0x65, 0xdd, 0x4f, 0x1e, 0x43, 0x7d, 0x25, 0x3f, 0x87, 0xa6, 0x68, + 0xd2, 0x26, 0x6e, 0x17, 0x0c, 0x07, 0x8e, 0x33, 0x06, 0x2f, 0x96, 0x93, 0x53, 0x68, 0x06, 0x6c, + 0xce, 0x9c, 0x0d, 0x5b, 0xbc, 0x0e, 0xbc, 0x55, 0xdc, 0xc2, 0x99, 0x35, 0xde, 0xe0, 0x01, 0xb3, + 0x43, 0xcf, 0x15, 0x6d, 0x5c, 0xc7, 0x38, 0x32, 0xa6, 0xa0, 0xed, 0xbb, 0xff, 0xff, 0x9f, 0xc6, + 0x0b, 0xce, 0x76, 0xc0, 0x03, 0x05, 0xbf, 0x80, 0x6a, 0x6c, 0xf5, 0x9d, 0x49, 0xa4, 0x64, 0x26, + 0xd1, 0x23, 0xfe, 0xec, 0x5e, 0xe4, 0x89, 0xf3, 0xea, 0x28, 0x03, 0xe3, 0x29, 0xc0, 0xd6, 0xe7, + 0x87, 0x58, 0xe3, 0x27, 0xa8, 0xc6, 0x76, 0xfe, 0xe0, 0xf6, 0x4a, 0xce, 0x5b, 0x3d, 0x07, 0x75, + 0xc5, 0x22, 0x5b, 0x9c, 0x74, 0xb8, 0x3f, 0xac, 0xc1, 0x98, 0x45, 0x36, 0x0a, 0xa9, 0x31, 0x85, + 0x6a, 0xec, 0x7b, 0x7e, 0x09, 0xee, 0xfc, 0xa9, 0x97, 0x5c, 0x42, 0x46, 0xff, 0x31, 0x6b, 0xdc, + 0x14, 0x9f, 0x32, 0xeb, 0x63, 0x50, 0x79, 0xd3, 0xf0, 0x17, 0x8d, 0x3c, 0xdf, 0x99, 0x8b, 0x8c, + 0x75, 0x94, 0x81, 0xf1, 0x04, 0x2a, 0xa2, 0x43, 0xb6, 0xdb, 0xa5, 0xdd, 0xed, 0xef, 0xa0, 0x22, + 0xba, 0xa1, 0xe8, 0xef, 0x94, 0x8f, 0x89, 0x8e, 0xf8, 0x97, 0xd8, 0x6f, 0x0a, 0x54, 0xe3, 0xcb, + 0x93, 0x36, 0x40, 0x6a, 0x98, 0x50, 0x57, 0x3a, 0xe5, 0x6e, 0x13, 0x77, 0x56, 0xc4, 0x7c, 0x5a, + 0xcf, 0xc6, 0xf2, 0x31, 0xca, 0x05, 0xf3, 0x49, 0x8a, 0x30, 0x51, 0x93, 0x01, 0x34, 0xe6, 0x9e, + 0x1b, 0x05, 0xde, 0x52, 0xc0, 0x65, 0xf1, 0x92, 0xdf, 0xe4, 0xc3, 0x83, 0xad, 0x10, 0x77, 0x29, + 0xe3, 0x7b, 0xa8, 0xc6, 0x89, 0xb9, 0xd5, 0xc3, 0xf5, 0x2c, 0x9c, 0x07, 0xce, 0x4c, 0xfe, 0x03, + 0xae, 0xe1, 0x76, 0xe1, 0x40, 0xa1, 0xbf, 0x96, 0xa0, 0xb1, 0x93, 0x9b, 0xbc, 0x84, 0x8a, 0xf3, + 0x96, 0x8f, 0x32, 0x45, 0x94, 0xf2, 0xac, 0xf0, 0x36, 0xc3, 0x0b, 0x7b, 0xc3, 0xc4, 0x95, 0x24, + 0x24, 0xe8, 0x5f, 0x6c, 0x37, 0x8a, 0x1f, 0xe2, 0x01, 0xfa, 0x47, 0xdb, 0x8d, 0x62, 0x9a, 0x43, + 0x9c, 0x96, 0x33, 0xb1, 0xfc, 0x11, 0xb4, 0x30, 0x83, 0xa4, 0xe5, 0x78, 0x7c, 0x99, 0x8c, 0x47, + 0xf5, 0x23, 0x68, 0xe1, 0x09, 0x49, 0xcb, 0x49, 0x79, 0x01, 0xda, 0x7e, 0x51, 0xf9, 0x3e, 0xdd, + 0xb3, 0x43, 0x69, 0xdf, 0x0e, 0xc6, 0xd9, 0x36, 0x53, 0x52, 0xe0, 0x43, 0x16, 0x32, 0xba, 0x29, + 0x93, 0x96, 0x75, 0xa0, 0x4b, 0xb6, 0xca, 0xb4, 0x84, 0x7c, 0xe5, 0xe9, 0x1f, 0x0a, 0xa8, 0xfc, + 0x87, 0x16, 0xf9, 0x02, 0x4e, 0xac, 0x9b, 0x57, 0xa3, 0xe1, 0xe4, 0xe2, 0x6e, 0x4c, 0x27, 0x93, + 0xfe, 0x39, 0xd5, 0x3e, 0x23, 0x04, 0x5a, 0x48, 0x2f, 0xe9, 0x60, 0x9a, 0xae, 0x29, 0xe4, 0x4b, + 0xf8, 0xdc, 0xbc, 0xb1, 0x46, 0xc3, 0x41, 0x7f, 0x4a, 0xd3, 0xe5, 0x12, 0xe7, 0x4d, 0x3a, 0x1a, + 0xde, 0x52, 0x4c, 0x17, 0xcb, 0xa4, 0x09, 0xb5, 0xbe, 0x69, 0xde, 0x59, 0x94, 0xa2, 0xa6, 0x92, + 0x13, 0x68, 0x20, 0x1d, 0x5f, 0xdf, 0x52, 0xb9, 0x50, 0xe1, 0xdb, 0x48, 0x07, 0xb7, 0x77, 0x68, + 0x0d, 0xb4, 0x23, 0x1e, 0x4d, 0xe8, 0x95, 0x29, 0xa2, 0x2a, 0x8f, 0x4c, 0xbc, 0xb6, 0x44, 0x54, + 0x23, 0x35, 0x50, 0x2f, 0xaf, 0x87, 0x57, 0x5a, 0x9d, 0x7f, 0x8d, 0x68, 0x9f, 0x6a, 0x40, 0xea, + 0x50, 0x39, 0xc7, 0xfe, 0xeb, 0xa9, 0xd6, 0xe0, 0x9f, 0x16, 0xde, 0x5c, 0x51, 0xad, 0xf9, 0xaa, + 0xf9, 0xfb, 0x7d, 0x5b, 0xf9, 0xf3, 0xbe, 0xad, 0xfc, 0x75, 0xdf, 0x56, 0xfe, 0x09, 0x00, 0x00, + 0xff, 0xff, 0x73, 0xdd, 0x78, 0x2b, 0x90, 0x0a, 0x00, 0x00, +} diff --git a/pb/trace.proto b/pb/trace.proto new file mode 100644 index 0000000..1b1c6a6 --- /dev/null +++ b/pb/trace.proto @@ -0,0 +1,135 @@ +syntax = "proto2"; + +package pubsub.pb; + +message TraceEvent { + optional Type type = 1; + optional bytes peerID = 2; + optional uint64 timestap = 3; + + optional PublishMessage publishMessage = 4; + optional RejectMessage rejectMessage = 5; + optional DuplicateMessage duplicateMessage = 6; + optional DeliverMessage deliverMessage = 7; + optional AddPeer addPeer = 8; + optional RemovePeer removePeer = 9; + optional RecvRPC recvRPC = 10; + optional SendRPC sendRPC = 11; + optional DropRPC dropRPC = 12; + optional Join join = 13; + optional Leave leave = 14; + optional Graft graft = 15; + optional Prune prune = 16; + + enum Type { + PUBLISH_MESSAGE = 0; + REJECT_MESSAGE = 1; + DUPLICATE_MESSAGE = 2; + DELIVER_MESSAGE = 3; + ADD_PEER = 4; + REMOVE_PEER = 5; + RECV_RPC = 6; + SEND_RPC = 7; + DROP_RPC = 8; + JOIN = 9; + LEAE = 10; + GRAFT = 11; + PRUNE = 12; + } + + message PublishMessage { + optional bytes messageID = 1; + } + + message RejectMessage { + optional bytes messageID = 1; + optional bytes receivedFrom = 2; + optional string reason = 3; + } + + message DuplicateMessage { + optional bytes messageID = 1; + optional bytes receivedFrom = 2; + } + + message DeliverMessage { + optional bytes messageID = 1; + } + + message AddPeer { + optional bytes peerID = 1; + optional string proto = 2; + } + + message RemovePeer { + optional bytes peerID = 1; + } + + message RecvRPC { + optional bytes receivedFrom = 1; + optional RPCMeta meta = 2; + } + + message SendRPC { + optional bytes sendTo = 1; + optional RPCMeta meta = 2; + } + + message DropRPC { + optional bytes sendTo = 1; + optional RPCMeta meta = 2; + } + + message Join { + optional string topic = 1; + } + + message Leave { + optional string topic = 2; + } + + message Graft { + optional bytes peerID = 1; + optional string topic = 2; + } + + message Prune { + optional bytes peerID = 1; + optional string topic = 2; + } + + message RPCMeta { + repeated bytes messageIDs = 1; + repeated SubMeta subMeta = 2; + optional ControlMeta controlMeta = 3; + } + + message SubMeta { + optional bool subscribe = 1; + optional string topic = 2; + } + + message ControlMeta { + repeated ControlIHaveMeta ihave = 1; + repeated ControlIWantMeta iwant = 2; + repeated ControlGraftMeta graft = 3; + repeated ControlPruneMeta prune = 4; + } + + message ControlIHaveMeta { + optional string topic = 1; + repeated bytes messageIDs = 2; + } + + message ControlIWantMeta { + repeated bytes messageIDs = 1; + } + + message ControlGraftMeta { + optional string topic = 1; + } + + message ControlPruneMeta { + optional string topic = 1; + } +} From 040cabe3b02b124f92f2b97a3857de8aedc5ded0 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 11 Nov 2019 19:25:35 +0200 Subject: [PATCH 07/25] some minor fixes in trace pb --- pb/trace.pb.go | 241 +++++++++++++++++++++++++------------------------ pb/trace.proto | 8 +- 2 files changed, 125 insertions(+), 124 deletions(-) diff --git a/pb/trace.pb.go b/pb/trace.pb.go index 5ed8d14..7da395d 100644 --- a/pb/trace.pb.go +++ b/pb/trace.pb.go @@ -33,7 +33,7 @@ const ( TraceEvent_SEND_RPC TraceEvent_Type = 7 TraceEvent_DROP_RPC TraceEvent_Type = 8 TraceEvent_JOIN TraceEvent_Type = 9 - TraceEvent_LEAE TraceEvent_Type = 10 + TraceEvent_LEAVE TraceEvent_Type = 10 TraceEvent_GRAFT TraceEvent_Type = 11 TraceEvent_PRUNE TraceEvent_Type = 12 ) @@ -49,7 +49,7 @@ var TraceEvent_Type_name = map[int32]string{ 7: "SEND_RPC", 8: "DROP_RPC", 9: "JOIN", - 10: "LEAE", + 10: "LEAVE", 11: "GRAFT", 12: "PRUNE", } @@ -64,7 +64,7 @@ var TraceEvent_Type_value = map[string]int32{ "SEND_RPC": 7, "DROP_RPC": 8, "JOIN": 9, - "LEAE": 10, + "LEAVE": 10, "GRAFT": 11, "PRUNE": 12, } @@ -86,13 +86,13 @@ func (x *TraceEvent_Type) UnmarshalJSON(data []byte) error { return nil } func (TraceEvent_Type) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 0} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 0} } type TraceEvent struct { Type *TraceEvent_Type `protobuf:"varint,1,opt,name=type,enum=pubsub.pb.TraceEvent_Type" json:"type,omitempty"` PeerID []byte `protobuf:"bytes,2,opt,name=peerID" json:"peerID,omitempty"` - Timestap *uint64 `protobuf:"varint,3,opt,name=timestap" json:"timestap,omitempty"` + Timestamp *int64 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"` PublishMessage *TraceEvent_PublishMessage `protobuf:"bytes,4,opt,name=publishMessage" json:"publishMessage,omitempty"` RejectMessage *TraceEvent_RejectMessage `protobuf:"bytes,5,opt,name=rejectMessage" json:"rejectMessage,omitempty"` DuplicateMessage *TraceEvent_DuplicateMessage `protobuf:"bytes,6,opt,name=duplicateMessage" json:"duplicateMessage,omitempty"` @@ -115,7 +115,7 @@ func (m *TraceEvent) Reset() { *m = TraceEvent{} } func (m *TraceEvent) String() string { return proto.CompactTextString(m) } func (*TraceEvent) ProtoMessage() {} func (*TraceEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0} + return fileDescriptor_trace_31b365b8afda32be, []int{0} } func (m *TraceEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -158,9 +158,9 @@ func (m *TraceEvent) GetPeerID() []byte { return nil } -func (m *TraceEvent) GetTimestap() uint64 { - if m != nil && m.Timestap != nil { - return *m.Timestap +func (m *TraceEvent) GetTimestamp() int64 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp } return 0 } @@ -267,7 +267,7 @@ func (m *TraceEvent_PublishMessage) Reset() { *m = TraceEvent_PublishMes func (m *TraceEvent_PublishMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_PublishMessage) ProtoMessage() {} func (*TraceEvent_PublishMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 0} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 0} } func (m *TraceEvent_PublishMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -316,7 +316,7 @@ func (m *TraceEvent_RejectMessage) Reset() { *m = TraceEvent_RejectMessa func (m *TraceEvent_RejectMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RejectMessage) ProtoMessage() {} func (*TraceEvent_RejectMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 1} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 1} } func (m *TraceEvent_RejectMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -378,7 +378,7 @@ func (m *TraceEvent_DuplicateMessage) Reset() { *m = TraceEvent_Duplicat func (m *TraceEvent_DuplicateMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DuplicateMessage) ProtoMessage() {} func (*TraceEvent_DuplicateMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 2} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 2} } func (m *TraceEvent_DuplicateMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -432,7 +432,7 @@ func (m *TraceEvent_DeliverMessage) Reset() { *m = TraceEvent_DeliverMes func (m *TraceEvent_DeliverMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DeliverMessage) ProtoMessage() {} func (*TraceEvent_DeliverMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 3} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 3} } func (m *TraceEvent_DeliverMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -480,7 +480,7 @@ func (m *TraceEvent_AddPeer) Reset() { *m = TraceEvent_AddPeer{} } func (m *TraceEvent_AddPeer) String() string { return proto.CompactTextString(m) } func (*TraceEvent_AddPeer) ProtoMessage() {} func (*TraceEvent_AddPeer) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 4} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 4} } func (m *TraceEvent_AddPeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -534,7 +534,7 @@ func (m *TraceEvent_RemovePeer) Reset() { *m = TraceEvent_RemovePeer{} } func (m *TraceEvent_RemovePeer) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RemovePeer) ProtoMessage() {} func (*TraceEvent_RemovePeer) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 5} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 5} } func (m *TraceEvent_RemovePeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -582,7 +582,7 @@ func (m *TraceEvent_RecvRPC) Reset() { *m = TraceEvent_RecvRPC{} } func (m *TraceEvent_RecvRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RecvRPC) ProtoMessage() {} func (*TraceEvent_RecvRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 6} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 6} } func (m *TraceEvent_RecvRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -637,7 +637,7 @@ func (m *TraceEvent_SendRPC) Reset() { *m = TraceEvent_SendRPC{} } func (m *TraceEvent_SendRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_SendRPC) ProtoMessage() {} func (*TraceEvent_SendRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 7} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 7} } func (m *TraceEvent_SendRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -692,7 +692,7 @@ func (m *TraceEvent_DropRPC) Reset() { *m = TraceEvent_DropRPC{} } func (m *TraceEvent_DropRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DropRPC) ProtoMessage() {} func (*TraceEvent_DropRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 8} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 8} } func (m *TraceEvent_DropRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -746,7 +746,7 @@ func (m *TraceEvent_Join) Reset() { *m = TraceEvent_Join{} } func (m *TraceEvent_Join) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Join) ProtoMessage() {} func (*TraceEvent_Join) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 9} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 9} } func (m *TraceEvent_Join) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -793,7 +793,7 @@ func (m *TraceEvent_Leave) Reset() { *m = TraceEvent_Leave{} } func (m *TraceEvent_Leave) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Leave) ProtoMessage() {} func (*TraceEvent_Leave) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 10} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 10} } func (m *TraceEvent_Leave) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -841,7 +841,7 @@ func (m *TraceEvent_Graft) Reset() { *m = TraceEvent_Graft{} } func (m *TraceEvent_Graft) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Graft) ProtoMessage() {} func (*TraceEvent_Graft) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 11} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 11} } func (m *TraceEvent_Graft) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -896,7 +896,7 @@ func (m *TraceEvent_Prune) Reset() { *m = TraceEvent_Prune{} } func (m *TraceEvent_Prune) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Prune) ProtoMessage() {} func (*TraceEvent_Prune) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 12} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 12} } func (m *TraceEvent_Prune) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -941,8 +941,8 @@ func (m *TraceEvent_Prune) GetTopic() string { type TraceEvent_RPCMeta struct { MessageIDs [][]byte `protobuf:"bytes,1,rep,name=messageIDs" json:"messageIDs,omitempty"` - SubMeta []*TraceEvent_SubMeta `protobuf:"bytes,2,rep,name=subMeta" json:"subMeta,omitempty"` - ControlMeta *TraceEvent_ControlMeta `protobuf:"bytes,3,opt,name=controlMeta" json:"controlMeta,omitempty"` + Subscription []*TraceEvent_SubMeta `protobuf:"bytes,2,rep,name=subscription" json:"subscription,omitempty"` + Control *TraceEvent_ControlMeta `protobuf:"bytes,3,opt,name=control" json:"control,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -952,7 +952,7 @@ func (m *TraceEvent_RPCMeta) Reset() { *m = TraceEvent_RPCMeta{} } func (m *TraceEvent_RPCMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RPCMeta) ProtoMessage() {} func (*TraceEvent_RPCMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 13} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 13} } func (m *TraceEvent_RPCMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -988,16 +988,16 @@ func (m *TraceEvent_RPCMeta) GetMessageIDs() [][]byte { return nil } -func (m *TraceEvent_RPCMeta) GetSubMeta() []*TraceEvent_SubMeta { +func (m *TraceEvent_RPCMeta) GetSubscription() []*TraceEvent_SubMeta { if m != nil { - return m.SubMeta + return m.Subscription } return nil } -func (m *TraceEvent_RPCMeta) GetControlMeta() *TraceEvent_ControlMeta { +func (m *TraceEvent_RPCMeta) GetControl() *TraceEvent_ControlMeta { if m != nil { - return m.ControlMeta + return m.Control } return nil } @@ -1014,7 +1014,7 @@ func (m *TraceEvent_SubMeta) Reset() { *m = TraceEvent_SubMeta{} } func (m *TraceEvent_SubMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_SubMeta) ProtoMessage() {} func (*TraceEvent_SubMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 14} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 14} } func (m *TraceEvent_SubMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1071,7 +1071,7 @@ func (m *TraceEvent_ControlMeta) Reset() { *m = TraceEvent_ControlMeta{} func (m *TraceEvent_ControlMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlMeta) ProtoMessage() {} func (*TraceEvent_ControlMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 15} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 15} } func (m *TraceEvent_ControlMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1140,7 +1140,7 @@ func (m *TraceEvent_ControlIHaveMeta) Reset() { *m = TraceEvent_ControlI func (m *TraceEvent_ControlIHaveMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlIHaveMeta) ProtoMessage() {} func (*TraceEvent_ControlIHaveMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 16} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 16} } func (m *TraceEvent_ControlIHaveMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1194,7 +1194,7 @@ func (m *TraceEvent_ControlIWantMeta) Reset() { *m = TraceEvent_ControlI func (m *TraceEvent_ControlIWantMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlIWantMeta) ProtoMessage() {} func (*TraceEvent_ControlIWantMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 17} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 17} } func (m *TraceEvent_ControlIWantMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1241,7 +1241,7 @@ func (m *TraceEvent_ControlGraftMeta) Reset() { *m = TraceEvent_ControlG func (m *TraceEvent_ControlGraftMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlGraftMeta) ProtoMessage() {} func (*TraceEvent_ControlGraftMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 18} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 18} } func (m *TraceEvent_ControlGraftMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1288,7 +1288,7 @@ func (m *TraceEvent_ControlPruneMeta) Reset() { *m = TraceEvent_ControlP func (m *TraceEvent_ControlPruneMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlPruneMeta) ProtoMessage() {} func (*TraceEvent_ControlPruneMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_c3fa177daeafa133, []int{0, 19} + return fileDescriptor_trace_31b365b8afda32be, []int{0, 19} } func (m *TraceEvent_ControlPruneMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1374,10 +1374,10 @@ func (m *TraceEvent) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintTrace(dAtA, i, uint64(len(m.PeerID))) i += copy(dAtA[i:], m.PeerID) } - if m.Timestap != nil { + if m.Timestamp != nil { dAtA[i] = 0x18 i++ - i = encodeVarintTrace(dAtA, i, uint64(*m.Timestap)) + i = encodeVarintTrace(dAtA, i, uint64(*m.Timestamp)) } if m.PublishMessage != nil { dAtA[i] = 0x22 @@ -1957,8 +1957,8 @@ func (m *TraceEvent_RPCMeta) MarshalTo(dAtA []byte) (int, error) { i += copy(dAtA[i:], b) } } - if len(m.SubMeta) > 0 { - for _, msg := range m.SubMeta { + if len(m.Subscription) > 0 { + for _, msg := range m.Subscription { dAtA[i] = 0x12 i++ i = encodeVarintTrace(dAtA, i, uint64(msg.Size())) @@ -1969,11 +1969,11 @@ func (m *TraceEvent_RPCMeta) MarshalTo(dAtA []byte) (int, error) { i += n } } - if m.ControlMeta != nil { + if m.Control != nil { dAtA[i] = 0x1a i++ - i = encodeVarintTrace(dAtA, i, uint64(m.ControlMeta.Size())) - n17, err := m.ControlMeta.MarshalTo(dAtA[i:]) + i = encodeVarintTrace(dAtA, i, uint64(m.Control.Size())) + n17, err := m.Control.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -2231,8 +2231,8 @@ func (m *TraceEvent) Size() (n int) { l = len(m.PeerID) n += 1 + l + sovTrace(uint64(l)) } - if m.Timestap != nil { - n += 1 + sovTrace(uint64(*m.Timestap)) + if m.Timestamp != nil { + n += 1 + sovTrace(uint64(*m.Timestamp)) } if m.PublishMessage != nil { l = m.PublishMessage.Size() @@ -2548,14 +2548,14 @@ func (m *TraceEvent_RPCMeta) Size() (n int) { n += 1 + l + sovTrace(uint64(l)) } } - if len(m.SubMeta) > 0 { - for _, e := range m.SubMeta { + if len(m.Subscription) > 0 { + for _, e := range m.Subscription { l = e.Size() n += 1 + l + sovTrace(uint64(l)) } } - if m.ControlMeta != nil { - l = m.ControlMeta.Size() + if m.Control != nil { + l = m.Control.Size() n += 1 + l + sovTrace(uint64(l)) } if m.XXX_unrecognized != nil { @@ -2786,9 +2786,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Timestap", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } - var v uint64 + var v int64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTrace @@ -2798,12 +2798,12 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= (uint64(b) & 0x7F) << shift + v |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } - m.Timestap = &v + m.Timestamp = &v case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PublishMessage", wireType) @@ -4660,7 +4660,7 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SubMeta", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Subscription", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4684,14 +4684,14 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SubMeta = append(m.SubMeta, &TraceEvent_SubMeta{}) - if err := m.SubMeta[len(m.SubMeta)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Subscription = append(m.Subscription, &TraceEvent_SubMeta{}) + if err := m.Subscription[len(m.Subscription)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ControlMeta", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Control", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4715,10 +4715,10 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ControlMeta == nil { - m.ControlMeta = &TraceEvent_ControlMeta{} + if m.Control == nil { + m.Control = &TraceEvent_ControlMeta{} } - if err := m.ControlMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Control.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5478,66 +5478,67 @@ var ( ErrIntOverflowTrace = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("trace.proto", fileDescriptor_trace_c3fa177daeafa133) } +func init() { proto.RegisterFile("trace.proto", fileDescriptor_trace_31b365b8afda32be) } -var fileDescriptor_trace_c3fa177daeafa133 = []byte{ - // 922 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xd1, 0x8e, 0xda, 0x46, - 0x14, 0x86, 0x6b, 0x30, 0x0b, 0x1c, 0x58, 0xd6, 0x9d, 0xa6, 0x95, 0xe5, 0x26, 0x88, 0x6e, 0xa3, - 0x88, 0x2b, 0xa4, 0xac, 0x54, 0xe5, 0x26, 0x95, 0x4a, 0xf0, 0x64, 0x97, 0x15, 0xec, 0x5a, 0x07, - 0x76, 0x7b, 0xb9, 0x35, 0x30, 0x4d, 0x1c, 0x81, 0x6d, 0xd9, 0x86, 0x2a, 0x0f, 0xd0, 0x67, 0xe9, - 0xab, 0xf4, 0xaa, 0xea, 0x23, 0x54, 0x7b, 0xd3, 0xd7, 0xa8, 0x66, 0xc6, 0x36, 0x98, 0x18, 0x6f, - 0xda, 0xe6, 0xce, 0x67, 0xe6, 0xff, 0xce, 0xcc, 0x99, 0xfd, 0xcf, 0x59, 0xa0, 0x11, 0x05, 0xf6, - 0x9c, 0xf5, 0xfc, 0xc0, 0x8b, 0x3c, 0x52, 0xf7, 0xd7, 0xb3, 0x70, 0x3d, 0xeb, 0xf9, 0xb3, 0xd3, - 0xbf, 0x1f, 0x01, 0x4c, 0xf9, 0x16, 0xdd, 0x30, 0x37, 0x22, 0x3d, 0x50, 0xa3, 0xf7, 0x3e, 0xd3, - 0x95, 0x8e, 0xd2, 0x6d, 0x9d, 0x19, 0xbd, 0x54, 0xd8, 0xdb, 0x8a, 0x7a, 0xd3, 0xf7, 0x3e, 0x43, - 0xa1, 0x23, 0x5f, 0xc1, 0x91, 0xcf, 0x58, 0x30, 0x34, 0xf5, 0x52, 0x47, 0xe9, 0x36, 0x31, 0x8e, - 0x88, 0x01, 0xb5, 0xc8, 0x59, 0xb1, 0x30, 0xb2, 0x7d, 0xbd, 0xdc, 0x51, 0xba, 0x2a, 0xa6, 0x31, - 0x19, 0x41, 0xcb, 0x5f, 0xcf, 0x96, 0x4e, 0xf8, 0x76, 0xcc, 0xc2, 0xd0, 0x7e, 0xc3, 0x74, 0xb5, - 0xa3, 0x74, 0x1b, 0x67, 0x4f, 0xf3, 0x4f, 0xb3, 0x32, 0x5a, 0xdc, 0x63, 0xc9, 0x10, 0x8e, 0x03, - 0xf6, 0x8e, 0xcd, 0xa3, 0x24, 0x59, 0x45, 0x24, 0xfb, 0x36, 0x3f, 0x19, 0xee, 0x4a, 0x31, 0x4b, - 0x12, 0x04, 0x6d, 0xb1, 0xf6, 0x97, 0xce, 0xdc, 0x8e, 0x58, 0x92, 0xed, 0x48, 0x64, 0x7b, 0x96, - 0x9f, 0xcd, 0xdc, 0x53, 0xe3, 0x07, 0x3c, 0x2f, 0x76, 0xc1, 0x96, 0xce, 0x86, 0x05, 0x49, 0xc6, - 0x6a, 0x51, 0xb1, 0x66, 0x46, 0x8b, 0x7b, 0x2c, 0x79, 0x01, 0x55, 0x7b, 0xb1, 0xb0, 0x18, 0x0b, - 0xf4, 0x9a, 0x48, 0xf3, 0x24, 0x3f, 0x4d, 0x5f, 0x8a, 0x30, 0x51, 0x93, 0x1f, 0x00, 0x02, 0xb6, - 0xf2, 0x36, 0x4c, 0xb0, 0x75, 0xc1, 0x76, 0x0e, 0x3d, 0x51, 0xa2, 0xc3, 0x1d, 0x86, 0x1f, 0x1d, - 0xb0, 0xf9, 0x06, 0xad, 0x81, 0x0e, 0x45, 0x47, 0xa3, 0x14, 0x61, 0xa2, 0xe6, 0x60, 0xc8, 0xdc, - 0x05, 0x07, 0x1b, 0x45, 0xe0, 0x44, 0x8a, 0x30, 0x51, 0x73, 0x70, 0x11, 0x78, 0x3e, 0x07, 0x9b, - 0x45, 0xa0, 0x29, 0x45, 0x98, 0xa8, 0xb9, 0x89, 0xdf, 0x79, 0x8e, 0xab, 0x1f, 0x0b, 0xea, 0x80, - 0x89, 0x2f, 0x3d, 0xc7, 0x45, 0xa1, 0x23, 0xcf, 0xa1, 0xb2, 0x64, 0xf6, 0x86, 0xe9, 0x2d, 0x01, - 0x7c, 0x9d, 0x0f, 0x8c, 0xb8, 0x04, 0xa5, 0x92, 0x23, 0x6f, 0x02, 0xfb, 0xe7, 0x48, 0x3f, 0x29, - 0x42, 0xce, 0xb9, 0x04, 0xa5, 0x92, 0x23, 0x7e, 0xb0, 0x76, 0x99, 0xae, 0x15, 0x21, 0x16, 0x97, - 0xa0, 0x54, 0x1a, 0x3d, 0x68, 0x65, 0xdd, 0x4f, 0x1e, 0x43, 0x7d, 0x25, 0x3f, 0x87, 0xa6, 0x68, - 0xd2, 0x26, 0x6e, 0x17, 0x0c, 0x07, 0x8e, 0x33, 0x06, 0x2f, 0x96, 0x93, 0x53, 0x68, 0x06, 0x6c, - 0xce, 0x9c, 0x0d, 0x5b, 0xbc, 0x0e, 0xbc, 0x55, 0xdc, 0xc2, 0x99, 0x35, 0xde, 0xe0, 0x01, 0xb3, - 0x43, 0xcf, 0x15, 0x6d, 0x5c, 0xc7, 0x38, 0x32, 0xa6, 0xa0, 0xed, 0xbb, 0xff, 0xff, 0x9f, 0xc6, - 0x0b, 0xce, 0x76, 0xc0, 0x03, 0x05, 0xbf, 0x80, 0x6a, 0x6c, 0xf5, 0x9d, 0x49, 0xa4, 0x64, 0x26, - 0xd1, 0x23, 0xfe, 0xec, 0x5e, 0xe4, 0x89, 0xf3, 0xea, 0x28, 0x03, 0xe3, 0x29, 0xc0, 0xd6, 0xe7, - 0x87, 0x58, 0xe3, 0x27, 0xa8, 0xc6, 0x76, 0xfe, 0xe0, 0xf6, 0x4a, 0xce, 0x5b, 0x3d, 0x07, 0x75, - 0xc5, 0x22, 0x5b, 0x9c, 0x74, 0xb8, 0x3f, 0xac, 0xc1, 0x98, 0x45, 0x36, 0x0a, 0xa9, 0x31, 0x85, - 0x6a, 0xec, 0x7b, 0x7e, 0x09, 0xee, 0xfc, 0xa9, 0x97, 0x5c, 0x42, 0x46, 0xff, 0x31, 0x6b, 0xdc, - 0x14, 0x9f, 0x32, 0xeb, 0x63, 0x50, 0x79, 0xd3, 0xf0, 0x17, 0x8d, 0x3c, 0xdf, 0x99, 0x8b, 0x8c, - 0x75, 0x94, 0x81, 0xf1, 0x04, 0x2a, 0xa2, 0x43, 0xb6, 0xdb, 0xa5, 0xdd, 0xed, 0xef, 0xa0, 0x22, - 0xba, 0xa1, 0xe8, 0xef, 0x94, 0x8f, 0x89, 0x8e, 0xf8, 0x97, 0xd8, 0x6f, 0x0a, 0x54, 0xe3, 0xcb, - 0x93, 0x36, 0x40, 0x6a, 0x98, 0x50, 0x57, 0x3a, 0xe5, 0x6e, 0x13, 0x77, 0x56, 0xc4, 0x7c, 0x5a, - 0xcf, 0xc6, 0xf2, 0x31, 0xca, 0x05, 0xf3, 0x49, 0x8a, 0x30, 0x51, 0x93, 0x01, 0x34, 0xe6, 0x9e, - 0x1b, 0x05, 0xde, 0x52, 0xc0, 0x65, 0xf1, 0x92, 0xdf, 0xe4, 0xc3, 0x83, 0xad, 0x10, 0x77, 0x29, - 0xe3, 0x7b, 0xa8, 0xc6, 0x89, 0xb9, 0xd5, 0xc3, 0xf5, 0x2c, 0x9c, 0x07, 0xce, 0x4c, 0xfe, 0x03, - 0xae, 0xe1, 0x76, 0xe1, 0x40, 0xa1, 0xbf, 0x96, 0xa0, 0xb1, 0x93, 0x9b, 0xbc, 0x84, 0x8a, 0xf3, - 0x96, 0x8f, 0x32, 0x45, 0x94, 0xf2, 0xac, 0xf0, 0x36, 0xc3, 0x0b, 0x7b, 0xc3, 0xc4, 0x95, 0x24, - 0x24, 0xe8, 0x5f, 0x6c, 0x37, 0x8a, 0x1f, 0xe2, 0x01, 0xfa, 0x47, 0xdb, 0x8d, 0x62, 0x9a, 0x43, - 0x9c, 0x96, 0x33, 0xb1, 0xfc, 0x11, 0xb4, 0x30, 0x83, 0xa4, 0xe5, 0x78, 0x7c, 0x99, 0x8c, 0x47, - 0xf5, 0x23, 0x68, 0xe1, 0x09, 0x49, 0xcb, 0x49, 0x79, 0x01, 0xda, 0x7e, 0x51, 0xf9, 0x3e, 0xdd, - 0xb3, 0x43, 0x69, 0xdf, 0x0e, 0xc6, 0xd9, 0x36, 0x53, 0x52, 0xe0, 0x43, 0x16, 0x32, 0xba, 0x29, - 0x93, 0x96, 0x75, 0xa0, 0x4b, 0xb6, 0xca, 0xb4, 0x84, 0x7c, 0xe5, 0xe9, 0x1f, 0x0a, 0xa8, 0xfc, - 0x87, 0x16, 0xf9, 0x02, 0x4e, 0xac, 0x9b, 0x57, 0xa3, 0xe1, 0xe4, 0xe2, 0x6e, 0x4c, 0x27, 0x93, - 0xfe, 0x39, 0xd5, 0x3e, 0x23, 0x04, 0x5a, 0x48, 0x2f, 0xe9, 0x60, 0x9a, 0xae, 0x29, 0xe4, 0x4b, - 0xf8, 0xdc, 0xbc, 0xb1, 0x46, 0xc3, 0x41, 0x7f, 0x4a, 0xd3, 0xe5, 0x12, 0xe7, 0x4d, 0x3a, 0x1a, - 0xde, 0x52, 0x4c, 0x17, 0xcb, 0xa4, 0x09, 0xb5, 0xbe, 0x69, 0xde, 0x59, 0x94, 0xa2, 0xa6, 0x92, - 0x13, 0x68, 0x20, 0x1d, 0x5f, 0xdf, 0x52, 0xb9, 0x50, 0xe1, 0xdb, 0x48, 0x07, 0xb7, 0x77, 0x68, - 0x0d, 0xb4, 0x23, 0x1e, 0x4d, 0xe8, 0x95, 0x29, 0xa2, 0x2a, 0x8f, 0x4c, 0xbc, 0xb6, 0x44, 0x54, - 0x23, 0x35, 0x50, 0x2f, 0xaf, 0x87, 0x57, 0x5a, 0x9d, 0x7f, 0x8d, 0x68, 0x9f, 0x6a, 0x40, 0xea, - 0x50, 0x39, 0xc7, 0xfe, 0xeb, 0xa9, 0xd6, 0xe0, 0x9f, 0x16, 0xde, 0x5c, 0x51, 0xad, 0xf9, 0xaa, - 0xf9, 0xfb, 0x7d, 0x5b, 0xf9, 0xf3, 0xbe, 0xad, 0xfc, 0x75, 0xdf, 0x56, 0xfe, 0x09, 0x00, 0x00, - 0xff, 0xff, 0x73, 0xdd, 0x78, 0x2b, 0x90, 0x0a, 0x00, 0x00, +var fileDescriptor_trace_31b365b8afda32be = []byte{ + // 931 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xcd, 0x6e, 0xdb, 0x46, + 0x10, 0xc7, 0x4b, 0x7d, 0x58, 0xd2, 0x88, 0x96, 0xd9, 0x6d, 0x5a, 0x10, 0x6c, 0x62, 0xa8, 0x6e, + 0x10, 0xe8, 0x24, 0x20, 0x06, 0x8a, 0x1c, 0x9a, 0x02, 0x55, 0xc4, 0x8d, 0x2d, 0x43, 0xb6, 0x89, + 0x91, 0xec, 0x1e, 0x5d, 0x4a, 0xda, 0x26, 0x0c, 0x24, 0x92, 0x20, 0x57, 0x2a, 0xf2, 0x00, 0x7d, + 0x98, 0xbe, 0x49, 0x6f, 0xed, 0x23, 0x14, 0x3e, 0xf7, 0x21, 0x8a, 0xdd, 0x25, 0x25, 0x51, 0xa1, + 0xe8, 0xf4, 0xe3, 0xc6, 0x99, 0xfd, 0xff, 0x66, 0x77, 0xd6, 0xff, 0x59, 0x0b, 0x9a, 0x3c, 0x72, + 0xa7, 0xac, 0x1b, 0x46, 0x01, 0x0f, 0x48, 0x23, 0x5c, 0x4e, 0xe2, 0xe5, 0xa4, 0x1b, 0x4e, 0x4e, + 0xfe, 0x7a, 0x04, 0x30, 0x16, 0x4b, 0x74, 0xc5, 0x7c, 0x4e, 0xba, 0x50, 0xe1, 0xef, 0x43, 0x66, + 0x6a, 0x6d, 0xad, 0xd3, 0x3a, 0xb5, 0xba, 0x6b, 0x61, 0x77, 0x23, 0xea, 0x8e, 0xdf, 0x87, 0x0c, + 0xa5, 0x8e, 0x7c, 0x01, 0x07, 0x21, 0x63, 0xd1, 0xc0, 0x36, 0x4b, 0x6d, 0xad, 0xa3, 0x63, 0x12, + 0x91, 0xc7, 0xd0, 0xe0, 0xde, 0x82, 0xc5, 0xdc, 0x5d, 0x84, 0x66, 0xb9, 0xad, 0x75, 0xca, 0xb8, + 0x49, 0x90, 0x21, 0xb4, 0xc2, 0xe5, 0x64, 0xee, 0xc5, 0x6f, 0x2f, 0x59, 0x1c, 0xbb, 0x6f, 0x98, + 0x59, 0x69, 0x6b, 0x9d, 0xe6, 0xe9, 0xd3, 0xfc, 0xfd, 0x9c, 0x8c, 0x16, 0x77, 0x58, 0x32, 0x80, + 0xc3, 0x88, 0xbd, 0x63, 0x53, 0x9e, 0x16, 0xab, 0xca, 0x62, 0x5f, 0xe7, 0x17, 0xc3, 0x6d, 0x29, + 0x66, 0x49, 0x82, 0x60, 0xcc, 0x96, 0xe1, 0xdc, 0x9b, 0xba, 0x9c, 0xa5, 0xd5, 0x0e, 0x64, 0xb5, + 0x67, 0xf9, 0xd5, 0xec, 0x1d, 0x35, 0x7e, 0xc0, 0x8b, 0x66, 0x67, 0x6c, 0xee, 0xad, 0x58, 0x94, + 0x56, 0xac, 0x15, 0x35, 0x6b, 0x67, 0xb4, 0xb8, 0xc3, 0x92, 0x17, 0x50, 0x73, 0x67, 0x33, 0x87, + 0xb1, 0xc8, 0xac, 0xcb, 0x32, 0x4f, 0xf2, 0xcb, 0xf4, 0x94, 0x08, 0x53, 0x35, 0xf9, 0x1e, 0x20, + 0x62, 0x8b, 0x60, 0xc5, 0x24, 0xdb, 0x90, 0x6c, 0x7b, 0xdf, 0x15, 0xa5, 0x3a, 0xdc, 0x62, 0xc4, + 0xd6, 0x11, 0x9b, 0xae, 0xd0, 0xe9, 0x9b, 0x50, 0xb4, 0x35, 0x2a, 0x11, 0xa6, 0x6a, 0x01, 0xc6, + 0xcc, 0x9f, 0x09, 0xb0, 0x59, 0x04, 0x8e, 0x94, 0x08, 0x53, 0xb5, 0x00, 0x67, 0x51, 0x10, 0x0a, + 0x50, 0x2f, 0x02, 0x6d, 0x25, 0xc2, 0x54, 0x2d, 0x6c, 0xfc, 0x2e, 0xf0, 0x7c, 0xf3, 0x50, 0x52, + 0x7b, 0x6c, 0x7c, 0x11, 0x78, 0x3e, 0x4a, 0x1d, 0x79, 0x0e, 0xd5, 0x39, 0x73, 0x57, 0xcc, 0x6c, + 0x49, 0xe0, 0xcb, 0x7c, 0x60, 0x28, 0x24, 0xa8, 0x94, 0x02, 0x79, 0x13, 0xb9, 0x3f, 0x71, 0xf3, + 0xa8, 0x08, 0x39, 0x13, 0x12, 0x54, 0x4a, 0x81, 0x84, 0xd1, 0xd2, 0x67, 0xa6, 0x51, 0x84, 0x38, + 0x42, 0x82, 0x4a, 0x69, 0x75, 0xa1, 0x95, 0x75, 0xbf, 0x98, 0xac, 0x85, 0xfa, 0x1c, 0xd8, 0x72, + 0x4c, 0x75, 0xdc, 0x24, 0x2c, 0x0f, 0x0e, 0x33, 0x06, 0x2f, 0x96, 0x93, 0x13, 0xd0, 0x23, 0x36, + 0x65, 0xde, 0x8a, 0xcd, 0x5e, 0x47, 0xc1, 0x22, 0x19, 0xe2, 0x4c, 0x4e, 0x8c, 0x78, 0xc4, 0xdc, + 0x38, 0xf0, 0xe5, 0x1c, 0x37, 0x30, 0x89, 0xac, 0x31, 0x18, 0xbb, 0xee, 0xff, 0xef, 0xbb, 0x89, + 0x86, 0xb3, 0x13, 0xf0, 0x40, 0xc3, 0x2f, 0xa0, 0x96, 0x58, 0x7d, 0xeb, 0x2d, 0xd2, 0x32, 0x6f, + 0xd1, 0x23, 0x71, 0xed, 0x01, 0x0f, 0xe4, 0x7e, 0x0d, 0x54, 0x81, 0xf5, 0x14, 0x60, 0xe3, 0xf3, + 0x7d, 0xac, 0xf5, 0x23, 0xd4, 0x12, 0x3b, 0x7f, 0x70, 0x7a, 0x2d, 0xe7, 0xae, 0x9e, 0x43, 0x65, + 0xc1, 0xb8, 0x2b, 0x77, 0xda, 0x3f, 0x1f, 0x4e, 0xff, 0x92, 0x71, 0x17, 0xa5, 0xd4, 0x1a, 0x43, + 0x2d, 0xf1, 0xbd, 0x38, 0x84, 0x70, 0xfe, 0x38, 0x48, 0x0f, 0xa1, 0xa2, 0x7f, 0x59, 0x35, 0x19, + 0x8a, 0xff, 0xb3, 0xea, 0x63, 0xa8, 0x88, 0xa1, 0x11, 0x37, 0xca, 0x83, 0xd0, 0x9b, 0xca, 0x8a, + 0x0d, 0x54, 0x81, 0xf5, 0x04, 0xaa, 0x72, 0x42, 0x36, 0xcb, 0xa5, 0xed, 0xe5, 0x6f, 0xa0, 0x2a, + 0xa7, 0xa1, 0xe8, 0xef, 0x94, 0x8f, 0xc9, 0x89, 0xf8, 0x87, 0xd8, 0xaf, 0x1a, 0xd4, 0x92, 0xc3, + 0x93, 0x63, 0x80, 0xb5, 0x61, 0x62, 0x53, 0x6b, 0x97, 0x3b, 0x3a, 0x6e, 0x65, 0x48, 0x0f, 0xf4, + 0x78, 0x39, 0x89, 0xa7, 0x91, 0x17, 0x72, 0x2f, 0xf0, 0xcd, 0x52, 0xbb, 0x5c, 0xf0, 0x48, 0x2d, + 0x27, 0xf2, 0x46, 0x32, 0x08, 0xf9, 0x16, 0x6a, 0xd3, 0xc0, 0xe7, 0x51, 0x30, 0x97, 0x53, 0xd2, + 0x3c, 0xfd, 0x2a, 0x9f, 0xee, 0x2b, 0x91, 0xac, 0x90, 0x12, 0xd6, 0x77, 0x50, 0x4b, 0xaa, 0x0a, + 0xb3, 0x27, 0x75, 0x27, 0xea, 0x9f, 0x70, 0x1d, 0x37, 0x89, 0x3d, 0xad, 0xfe, 0x52, 0x82, 0xe6, + 0x56, 0x5d, 0xf2, 0x12, 0xaa, 0xde, 0x5b, 0xf1, 0x98, 0x69, 0xb2, 0x8f, 0x67, 0x85, 0x27, 0x19, + 0x9c, 0xbb, 0x2b, 0x26, 0x8f, 0xa3, 0x20, 0x49, 0xff, 0xec, 0xfa, 0x3c, 0xb9, 0x85, 0x07, 0xe8, + 0x1f, 0x5c, 0x9f, 0x27, 0xb4, 0x80, 0x04, 0xad, 0x5e, 0xc5, 0xf2, 0x47, 0xd0, 0xd2, 0x0e, 0x8a, + 0x56, 0x0f, 0xe4, 0xcb, 0xf4, 0x81, 0xac, 0x7c, 0x04, 0x2d, 0x5d, 0xa1, 0x68, 0xf5, 0x56, 0x9e, + 0x83, 0xb1, 0xdb, 0x54, 0xbe, 0x53, 0x77, 0x0c, 0x51, 0xda, 0x35, 0x84, 0x75, 0xba, 0xa9, 0x94, + 0x36, 0xf8, 0x90, 0x89, 0xac, 0xce, 0x9a, 0x59, 0xb7, 0xb5, 0x67, 0x4e, 0x36, 0xca, 0x75, 0x0b, + 0xf9, 0xca, 0x93, 0xdf, 0x35, 0xa8, 0x88, 0x1f, 0x5b, 0xe4, 0x33, 0x38, 0x72, 0x6e, 0x5e, 0x0d, + 0x07, 0xa3, 0xf3, 0xbb, 0x4b, 0x3a, 0x1a, 0xf5, 0xce, 0xa8, 0xf1, 0x09, 0x21, 0xd0, 0x42, 0x7a, + 0x41, 0xfb, 0xe3, 0x75, 0x4e, 0x23, 0x9f, 0xc3, 0xa7, 0xf6, 0x8d, 0x33, 0x1c, 0xf4, 0x7b, 0x63, + 0xba, 0x4e, 0x97, 0x04, 0x6f, 0xd3, 0xe1, 0xe0, 0x96, 0xe2, 0x3a, 0x59, 0x26, 0x3a, 0xd4, 0x7b, + 0xb6, 0x7d, 0xe7, 0x50, 0x8a, 0x46, 0x85, 0x1c, 0x41, 0x13, 0xe9, 0xe5, 0xf5, 0x2d, 0x55, 0x89, + 0xaa, 0x58, 0x46, 0xda, 0xbf, 0xbd, 0x43, 0xa7, 0x6f, 0x1c, 0x88, 0x68, 0x44, 0xaf, 0x6c, 0x19, + 0xd5, 0x44, 0x64, 0xe3, 0xb5, 0x23, 0xa3, 0x3a, 0xa9, 0x43, 0xe5, 0xe2, 0x7a, 0x70, 0x65, 0x34, + 0x48, 0x03, 0xaa, 0x43, 0xda, 0xbb, 0xa5, 0x06, 0x88, 0xcf, 0x33, 0xec, 0xbd, 0x1e, 0x1b, 0x4d, + 0xf1, 0xe9, 0xe0, 0xcd, 0x15, 0x35, 0xf4, 0x57, 0xfa, 0x6f, 0xf7, 0xc7, 0xda, 0x1f, 0xf7, 0xc7, + 0xda, 0x9f, 0xf7, 0xc7, 0xda, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf8, 0x22, 0x93, 0xfa, 0x95, + 0x0a, 0x00, 0x00, } diff --git a/pb/trace.proto b/pb/trace.proto index 1b1c6a6..3659c5a 100644 --- a/pb/trace.proto +++ b/pb/trace.proto @@ -5,7 +5,7 @@ package pubsub.pb; message TraceEvent { optional Type type = 1; optional bytes peerID = 2; - optional uint64 timestap = 3; + optional int64 timestamp = 3; optional PublishMessage publishMessage = 4; optional RejectMessage rejectMessage = 5; @@ -32,7 +32,7 @@ message TraceEvent { SEND_RPC = 7; DROP_RPC = 8; JOIN = 9; - LEAE = 10; + LEAVE = 10; GRAFT = 11; PRUNE = 12; } @@ -100,8 +100,8 @@ message TraceEvent { message RPCMeta { repeated bytes messageIDs = 1; - repeated SubMeta subMeta = 2; - optional ControlMeta controlMeta = 3; + repeated SubMeta subscription = 2; + optional ControlMeta control = 3; } message SubMeta { From 151ec256164c36efd13cef132e953202a4a144ab Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 11 Nov 2019 19:25:58 +0200 Subject: [PATCH 08/25] implement tracing details --- trace.go | 257 ++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 234 insertions(+), 23 deletions(-) diff --git a/trace.go b/trace.go index 99b4fa5..c04c734 100644 --- a/trace.go +++ b/trace.go @@ -1,8 +1,12 @@ package pubsub import ( + "time" + "github.com/libp2p/go-libp2p-core/peer" "github.com/libp2p/go-libp2p-core/protocol" + + pb "github.com/libp2p/go-libp2p-pubsub/pb" ) // Generic event tracer interface @@ -16,45 +20,135 @@ type pubsubTracer struct { } func (t *pubsubTracer) PublishMessage(msg *Message) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_PUBLISH_MESSAGE.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + PublishMessage: &pb.TraceEvent_PublishMessage{ + MessageID: []byte(msgID(msg.Message)), + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) RejectMessage(msg *Message, reason string) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_REJECT_MESSAGE.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + RejectMessage: &pb.TraceEvent_RejectMessage{ + MessageID: []byte(msgID(msg.Message)), + ReceivedFrom: []byte(msg.ReceivedFrom), + Reason: &reason, + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) DuplicateMessage(msg *Message) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_DUPLICATE_MESSAGE.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + DuplicateMessage: &pb.TraceEvent_DuplicateMessage{ + MessageID: []byte(msgID(msg.Message)), + ReceivedFrom: []byte(msg.ReceivedFrom), + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) DeliverMessage(msg *Message) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_DELIVER_MESSAGE.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + DeliverMessage: &pb.TraceEvent_DeliverMessage{ + MessageID: []byte(msgID(msg.Message)), + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) AddPeer(p peer.ID, proto protocol.ID) { - if t != nil { - // TODO + if t == nil { + return } + + protoStr := string(proto) + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_ADD_PEER.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + AddPeer: &pb.TraceEvent_AddPeer{ + PeerID: []byte(p), + Proto: &protoStr, + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) RemovePeer(p peer.ID) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_REMOVE_PEER.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + RemovePeer: &pb.TraceEvent_RemovePeer{ + PeerID: []byte(p), + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) RecvRPC(rpc *RPC) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_RECV_RPC.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + RecvRPC: &pb.TraceEvent_RecvRPC{ + ReceivedFrom: []byte(rpc.from), + Meta: traceRPCMeta(rpc), + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) SendRPC(rpc *RPC, p peer.ID) { @@ -69,26 +163,143 @@ func (t *pubsubTracer) DropRPC(rpc *RPC, p peer.ID) { } } -func (t *pubsubTracer) Join(topic string) { - if t != nil { - // TODO +func traceRPCMeta(rpc *RPC) *pb.TraceEvent_RPCMeta { + rpcMeta := new(pb.TraceEvent_RPCMeta) + + var mids [][]byte + for _, m := range rpc.Publish { + mids = append(mids, []byte(msgID(m))) } + rpcMeta.MessageIDs = mids + + var subs []*pb.TraceEvent_SubMeta + for _, sub := range rpc.Subscriptions { + subs = append(subs, &pb.TraceEvent_SubMeta{ + Subscribe: sub.Subscribe, + Topic: sub.Topicid, + }) + } + rpcMeta.Subscription = subs + + if rpc.Control != nil { + var ihave []*pb.TraceEvent_ControlIHaveMeta + for _, ctl := range rpc.Control.Ihave { + var mids [][]byte + for _, mid := range ctl.MessageIDs { + mids = append(mids, []byte(mid)) + } + ihave = append(ihave, &pb.TraceEvent_ControlIHaveMeta{ + Topic: ctl.TopicID, + MessageIDs: mids, + }) + } + + var iwant []*pb.TraceEvent_ControlIWantMeta + for _, ctl := range rpc.Control.Iwant { + var mids [][]byte + for _, mid := range ctl.MessageIDs { + mids = append(mids, []byte(mid)) + } + iwant = append(iwant, &pb.TraceEvent_ControlIWantMeta{ + MessageIDs: mids, + }) + } + + var graft []*pb.TraceEvent_ControlGraftMeta + for _, ctl := range rpc.Control.Graft { + graft = append(graft, &pb.TraceEvent_ControlGraftMeta{ + Topic: ctl.TopicID, + }) + } + + var prune []*pb.TraceEvent_ControlPruneMeta + for _, ctl := range rpc.Control.Prune { + prune = append(prune, &pb.TraceEvent_ControlPruneMeta{ + Topic: ctl.TopicID, + }) + } + + rpcMeta.Control = &pb.TraceEvent_ControlMeta{ + Ihave: ihave, + Iwant: iwant, + Graft: graft, + Prune: prune, + } + } + + return rpcMeta +} + +func (t *pubsubTracer) Join(topic string) { + if t == nil { + return + } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_JOIN.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + Join: &pb.TraceEvent_Join{ + Topic: &topic, + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) Leave(topic string) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_LEAVE.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + Leave: &pb.TraceEvent_Leave{ + Topic: &topic, + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) Graft(p peer.ID, topic string) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_GRAFT.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + Graft: &pb.TraceEvent_Graft{ + PeerID: []byte(p), + Topic: &topic, + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) Prune(p peer.ID, topic string) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_PRUNE.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + Prune: &pb.TraceEvent_Prune{ + PeerID: []byte(p), + Topic: &topic, + }, + } + + t.tracer.Trace(evt) } From ae0fcc6b4d2d3c094013683e1c3a437cc8fa72a1 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 11 Nov 2019 21:29:14 +0200 Subject: [PATCH 09/25] add traces for send/drop rpc forgotten! --- trace.go | 34 ++++++++++++++++++++++++++++++---- 1 file changed, 30 insertions(+), 4 deletions(-) diff --git a/trace.go b/trace.go index c04c734..af0fc03 100644 --- a/trace.go +++ b/trace.go @@ -152,15 +152,41 @@ func (t *pubsubTracer) RecvRPC(rpc *RPC) { } func (t *pubsubTracer) SendRPC(rpc *RPC, p peer.ID) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_SEND_RPC.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + SendRPC: &pb.TraceEvent_SendRPC{ + SendTo: []byte(rpc.from), + Meta: traceRPCMeta(rpc), + }, + } + + t.tracer.Trace(evt) } func (t *pubsubTracer) DropRPC(rpc *RPC, p peer.ID) { - if t != nil { - // TODO + if t == nil { + return } + + now := time.Now().UnixNano() + evt := &pb.TraceEvent{ + Type: pb.TraceEvent_DROP_RPC.Enum(), + PeerID: []byte(t.pid), + Timestamp: &now, + DropRPC: &pb.TraceEvent_DropRPC{ + SendTo: []byte(rpc.from), + Meta: traceRPCMeta(rpc), + }, + } + + t.tracer.Trace(evt) } func traceRPCMeta(rpc *RPC) *pb.TraceEvent_RPCMeta { From 3f30acdcf7a43cd2d1adca6af71725bcd63bc07b Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 11 Nov 2019 22:11:30 +0200 Subject: [PATCH 10/25] track topics in message tracing --- pb/trace.pb.go | 508 ++++++++++++++++++++++++++++++++++++++----------- pb/trace.proto | 8 +- trace.go | 10 +- 3 files changed, 416 insertions(+), 110 deletions(-) diff --git a/pb/trace.pb.go b/pb/trace.pb.go index 7da395d..00d4f45 100644 --- a/pb/trace.pb.go +++ b/pb/trace.pb.go @@ -86,7 +86,7 @@ func (x *TraceEvent_Type) UnmarshalJSON(data []byte) error { return nil } func (TraceEvent_Type) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 0} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 0} } type TraceEvent struct { @@ -115,7 +115,7 @@ func (m *TraceEvent) Reset() { *m = TraceEvent{} } func (m *TraceEvent) String() string { return proto.CompactTextString(m) } func (*TraceEvent) ProtoMessage() {} func (*TraceEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0} } func (m *TraceEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -258,6 +258,7 @@ func (m *TraceEvent) GetPrune() *TraceEvent_Prune { type TraceEvent_PublishMessage struct { MessageID []byte `protobuf:"bytes,1,opt,name=messageID" json:"messageID,omitempty"` + Topics []string `protobuf:"bytes,2,rep,name=topics" json:"topics,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -267,7 +268,7 @@ func (m *TraceEvent_PublishMessage) Reset() { *m = TraceEvent_PublishMes func (m *TraceEvent_PublishMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_PublishMessage) ProtoMessage() {} func (*TraceEvent_PublishMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 0} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 0} } func (m *TraceEvent_PublishMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -303,6 +304,13 @@ func (m *TraceEvent_PublishMessage) GetMessageID() []byte { return nil } +func (m *TraceEvent_PublishMessage) GetTopics() []string { + if m != nil { + return m.Topics + } + return nil +} + type TraceEvent_RejectMessage struct { MessageID []byte `protobuf:"bytes,1,opt,name=messageID" json:"messageID,omitempty"` ReceivedFrom []byte `protobuf:"bytes,2,opt,name=receivedFrom" json:"receivedFrom,omitempty"` @@ -316,7 +324,7 @@ func (m *TraceEvent_RejectMessage) Reset() { *m = TraceEvent_RejectMessa func (m *TraceEvent_RejectMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RejectMessage) ProtoMessage() {} func (*TraceEvent_RejectMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 1} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 1} } func (m *TraceEvent_RejectMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -378,7 +386,7 @@ func (m *TraceEvent_DuplicateMessage) Reset() { *m = TraceEvent_Duplicat func (m *TraceEvent_DuplicateMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DuplicateMessage) ProtoMessage() {} func (*TraceEvent_DuplicateMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 2} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 2} } func (m *TraceEvent_DuplicateMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -432,7 +440,7 @@ func (m *TraceEvent_DeliverMessage) Reset() { *m = TraceEvent_DeliverMes func (m *TraceEvent_DeliverMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DeliverMessage) ProtoMessage() {} func (*TraceEvent_DeliverMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 3} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 3} } func (m *TraceEvent_DeliverMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -480,7 +488,7 @@ func (m *TraceEvent_AddPeer) Reset() { *m = TraceEvent_AddPeer{} } func (m *TraceEvent_AddPeer) String() string { return proto.CompactTextString(m) } func (*TraceEvent_AddPeer) ProtoMessage() {} func (*TraceEvent_AddPeer) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 4} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 4} } func (m *TraceEvent_AddPeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -534,7 +542,7 @@ func (m *TraceEvent_RemovePeer) Reset() { *m = TraceEvent_RemovePeer{} } func (m *TraceEvent_RemovePeer) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RemovePeer) ProtoMessage() {} func (*TraceEvent_RemovePeer) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 5} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 5} } func (m *TraceEvent_RemovePeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -582,7 +590,7 @@ func (m *TraceEvent_RecvRPC) Reset() { *m = TraceEvent_RecvRPC{} } func (m *TraceEvent_RecvRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RecvRPC) ProtoMessage() {} func (*TraceEvent_RecvRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 6} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 6} } func (m *TraceEvent_RecvRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -637,7 +645,7 @@ func (m *TraceEvent_SendRPC) Reset() { *m = TraceEvent_SendRPC{} } func (m *TraceEvent_SendRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_SendRPC) ProtoMessage() {} func (*TraceEvent_SendRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 7} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 7} } func (m *TraceEvent_SendRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -692,7 +700,7 @@ func (m *TraceEvent_DropRPC) Reset() { *m = TraceEvent_DropRPC{} } func (m *TraceEvent_DropRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DropRPC) ProtoMessage() {} func (*TraceEvent_DropRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 8} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 8} } func (m *TraceEvent_DropRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -746,7 +754,7 @@ func (m *TraceEvent_Join) Reset() { *m = TraceEvent_Join{} } func (m *TraceEvent_Join) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Join) ProtoMessage() {} func (*TraceEvent_Join) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 9} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 9} } func (m *TraceEvent_Join) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -793,7 +801,7 @@ func (m *TraceEvent_Leave) Reset() { *m = TraceEvent_Leave{} } func (m *TraceEvent_Leave) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Leave) ProtoMessage() {} func (*TraceEvent_Leave) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 10} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 10} } func (m *TraceEvent_Leave) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -841,7 +849,7 @@ func (m *TraceEvent_Graft) Reset() { *m = TraceEvent_Graft{} } func (m *TraceEvent_Graft) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Graft) ProtoMessage() {} func (*TraceEvent_Graft) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 11} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 11} } func (m *TraceEvent_Graft) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -896,7 +904,7 @@ func (m *TraceEvent_Prune) Reset() { *m = TraceEvent_Prune{} } func (m *TraceEvent_Prune) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Prune) ProtoMessage() {} func (*TraceEvent_Prune) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 12} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 12} } func (m *TraceEvent_Prune) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -940,19 +948,19 @@ func (m *TraceEvent_Prune) GetTopic() string { } type TraceEvent_RPCMeta struct { - MessageIDs [][]byte `protobuf:"bytes,1,rep,name=messageIDs" json:"messageIDs,omitempty"` - Subscription []*TraceEvent_SubMeta `protobuf:"bytes,2,rep,name=subscription" json:"subscription,omitempty"` - Control *TraceEvent_ControlMeta `protobuf:"bytes,3,opt,name=control" json:"control,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Messages []*TraceEvent_MessageMeta `protobuf:"bytes,1,rep,name=messages" json:"messages,omitempty"` + Subscription []*TraceEvent_SubMeta `protobuf:"bytes,2,rep,name=subscription" json:"subscription,omitempty"` + Control *TraceEvent_ControlMeta `protobuf:"bytes,3,opt,name=control" json:"control,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *TraceEvent_RPCMeta) Reset() { *m = TraceEvent_RPCMeta{} } func (m *TraceEvent_RPCMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RPCMeta) ProtoMessage() {} func (*TraceEvent_RPCMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 13} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 13} } func (m *TraceEvent_RPCMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -981,9 +989,9 @@ func (m *TraceEvent_RPCMeta) XXX_DiscardUnknown() { var xxx_messageInfo_TraceEvent_RPCMeta proto.InternalMessageInfo -func (m *TraceEvent_RPCMeta) GetMessageIDs() [][]byte { +func (m *TraceEvent_RPCMeta) GetMessages() []*TraceEvent_MessageMeta { if m != nil { - return m.MessageIDs + return m.Messages } return nil } @@ -1002,6 +1010,61 @@ func (m *TraceEvent_RPCMeta) GetControl() *TraceEvent_ControlMeta { return nil } +type TraceEvent_MessageMeta struct { + MessageID []byte `protobuf:"bytes,1,opt,name=messageID" json:"messageID,omitempty"` + Topics []string `protobuf:"bytes,2,rep,name=topics" json:"topics,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEvent_MessageMeta) Reset() { *m = TraceEvent_MessageMeta{} } +func (m *TraceEvent_MessageMeta) String() string { return proto.CompactTextString(m) } +func (*TraceEvent_MessageMeta) ProtoMessage() {} +func (*TraceEvent_MessageMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 14} +} +func (m *TraceEvent_MessageMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEvent_MessageMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEvent_MessageMeta.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEvent_MessageMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_MessageMeta.Merge(dst, src) +} +func (m *TraceEvent_MessageMeta) XXX_Size() int { + return m.Size() +} +func (m *TraceEvent_MessageMeta) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEvent_MessageMeta.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEvent_MessageMeta proto.InternalMessageInfo + +func (m *TraceEvent_MessageMeta) GetMessageID() []byte { + if m != nil { + return m.MessageID + } + return nil +} + +func (m *TraceEvent_MessageMeta) GetTopics() []string { + if m != nil { + return m.Topics + } + return nil +} + type TraceEvent_SubMeta struct { Subscribe *bool `protobuf:"varint,1,opt,name=subscribe" json:"subscribe,omitempty"` Topic *string `protobuf:"bytes,2,opt,name=topic" json:"topic,omitempty"` @@ -1014,7 +1077,7 @@ func (m *TraceEvent_SubMeta) Reset() { *m = TraceEvent_SubMeta{} } func (m *TraceEvent_SubMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_SubMeta) ProtoMessage() {} func (*TraceEvent_SubMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 14} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 15} } func (m *TraceEvent_SubMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1071,7 +1134,7 @@ func (m *TraceEvent_ControlMeta) Reset() { *m = TraceEvent_ControlMeta{} func (m *TraceEvent_ControlMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlMeta) ProtoMessage() {} func (*TraceEvent_ControlMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 15} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 16} } func (m *TraceEvent_ControlMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1140,7 +1203,7 @@ func (m *TraceEvent_ControlIHaveMeta) Reset() { *m = TraceEvent_ControlI func (m *TraceEvent_ControlIHaveMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlIHaveMeta) ProtoMessage() {} func (*TraceEvent_ControlIHaveMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 16} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 17} } func (m *TraceEvent_ControlIHaveMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1194,7 +1257,7 @@ func (m *TraceEvent_ControlIWantMeta) Reset() { *m = TraceEvent_ControlI func (m *TraceEvent_ControlIWantMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlIWantMeta) ProtoMessage() {} func (*TraceEvent_ControlIWantMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 17} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 18} } func (m *TraceEvent_ControlIWantMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1241,7 +1304,7 @@ func (m *TraceEvent_ControlGraftMeta) Reset() { *m = TraceEvent_ControlG func (m *TraceEvent_ControlGraftMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlGraftMeta) ProtoMessage() {} func (*TraceEvent_ControlGraftMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 18} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 19} } func (m *TraceEvent_ControlGraftMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1288,7 +1351,7 @@ func (m *TraceEvent_ControlPruneMeta) Reset() { *m = TraceEvent_ControlP func (m *TraceEvent_ControlPruneMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlPruneMeta) ProtoMessage() {} func (*TraceEvent_ControlPruneMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_31b365b8afda32be, []int{0, 19} + return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 20} } func (m *TraceEvent_ControlPruneMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1340,6 +1403,7 @@ func init() { proto.RegisterType((*TraceEvent_Graft)(nil), "pubsub.pb.TraceEvent.Graft") proto.RegisterType((*TraceEvent_Prune)(nil), "pubsub.pb.TraceEvent.Prune") proto.RegisterType((*TraceEvent_RPCMeta)(nil), "pubsub.pb.TraceEvent.RPCMeta") + proto.RegisterType((*TraceEvent_MessageMeta)(nil), "pubsub.pb.TraceEvent.MessageMeta") proto.RegisterType((*TraceEvent_SubMeta)(nil), "pubsub.pb.TraceEvent.SubMeta") proto.RegisterType((*TraceEvent_ControlMeta)(nil), "pubsub.pb.TraceEvent.ControlMeta") proto.RegisterType((*TraceEvent_ControlIHaveMeta)(nil), "pubsub.pb.TraceEvent.ControlIHaveMeta") @@ -1538,6 +1602,21 @@ func (m *TraceEvent_PublishMessage) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintTrace(dAtA, i, uint64(len(m.MessageID))) i += copy(dAtA[i:], m.MessageID) } + if len(m.Topics) > 0 { + for _, s := range m.Topics { + dAtA[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } @@ -1949,12 +2028,16 @@ func (m *TraceEvent_RPCMeta) MarshalTo(dAtA []byte) (int, error) { _ = i var l int _ = l - if len(m.MessageIDs) > 0 { - for _, b := range m.MessageIDs { + if len(m.Messages) > 0 { + for _, msg := range m.Messages { dAtA[i] = 0xa i++ - i = encodeVarintTrace(dAtA, i, uint64(len(b))) - i += copy(dAtA[i:], b) + i = encodeVarintTrace(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n } } if len(m.Subscription) > 0 { @@ -1985,6 +2068,48 @@ func (m *TraceEvent_RPCMeta) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *TraceEvent_MessageMeta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEvent_MessageMeta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MessageID != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.MessageID))) + i += copy(dAtA[i:], m.MessageID) + } + if len(m.Topics) > 0 { + for _, s := range m.Topics { + dAtA[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + func (m *TraceEvent_SubMeta) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2302,6 +2427,12 @@ func (m *TraceEvent_PublishMessage) Size() (n int) { l = len(m.MessageID) n += 1 + l + sovTrace(uint64(l)) } + if len(m.Topics) > 0 { + for _, s := range m.Topics { + l = len(s) + n += 1 + l + sovTrace(uint64(l)) + } + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2542,9 +2673,9 @@ func (m *TraceEvent_RPCMeta) Size() (n int) { } var l int _ = l - if len(m.MessageIDs) > 0 { - for _, b := range m.MessageIDs { - l = len(b) + if len(m.Messages) > 0 { + for _, e := range m.Messages { + l = e.Size() n += 1 + l + sovTrace(uint64(l)) } } @@ -2564,6 +2695,28 @@ func (m *TraceEvent_RPCMeta) Size() (n int) { return n } +func (m *TraceEvent_MessageMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MessageID != nil { + l = len(m.MessageID) + n += 1 + l + sovTrace(uint64(l)) + } + if len(m.Topics) > 0 { + for _, s := range m.Topics { + l = len(s) + n += 1 + l + sovTrace(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func (m *TraceEvent_SubMeta) Size() (n int) { if m == nil { return 0 @@ -3315,6 +3468,35 @@ func (m *TraceEvent_PublishMessage) Unmarshal(dAtA []byte) error { m.MessageID = []byte{} } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topics", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Topics = append(m.Topics, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTrace(dAtA[iNdEx:]) @@ -4631,9 +4813,9 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MessageIDs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTrace @@ -4643,20 +4825,22 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTrace } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - m.MessageIDs = append(m.MessageIDs, make([]byte, postIndex-iNdEx)) - copy(m.MessageIDs[len(m.MessageIDs)-1], dAtA[iNdEx:postIndex]) + m.Messages = append(m.Messages, &TraceEvent_MessageMeta{}) + if err := m.Messages[len(m.Messages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 2: if wireType != 2 { @@ -4744,6 +4928,117 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { } return nil } +func (m *TraceEvent_MessageMeta) 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 ErrIntOverflowTrace + } + 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: MessageMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MessageMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MessageID = append(m.MessageID[:0], dAtA[iNdEx:postIndex]...) + if m.MessageID == nil { + m.MessageID = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topics", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + 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 ErrInvalidLengthTrace + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Topics = append(m.Topics, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *TraceEvent_SubMeta) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5478,67 +5773,68 @@ var ( ErrIntOverflowTrace = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("trace.proto", fileDescriptor_trace_31b365b8afda32be) } +func init() { proto.RegisterFile("trace.proto", fileDescriptor_trace_f5041bb48e7a4810) } -var fileDescriptor_trace_31b365b8afda32be = []byte{ - // 931 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xcd, 0x6e, 0xdb, 0x46, - 0x10, 0xc7, 0x4b, 0x7d, 0x58, 0xd2, 0x88, 0x96, 0xd9, 0x6d, 0x5a, 0x10, 0x6c, 0x62, 0xa8, 0x6e, - 0x10, 0xe8, 0x24, 0x20, 0x06, 0x8a, 0x1c, 0x9a, 0x02, 0x55, 0xc4, 0x8d, 0x2d, 0x43, 0xb6, 0x89, - 0x91, 0xec, 0x1e, 0x5d, 0x4a, 0xda, 0x26, 0x0c, 0x24, 0x92, 0x20, 0x57, 0x2a, 0xf2, 0x00, 0x7d, - 0x98, 0xbe, 0x49, 0x6f, 0xed, 0x23, 0x14, 0x3e, 0xf7, 0x21, 0x8a, 0xdd, 0x25, 0x25, 0x51, 0xa1, - 0xe8, 0xf4, 0xe3, 0xc6, 0x99, 0xfd, 0xff, 0x66, 0x77, 0xd6, 0xff, 0x59, 0x0b, 0x9a, 0x3c, 0x72, - 0xa7, 0xac, 0x1b, 0x46, 0x01, 0x0f, 0x48, 0x23, 0x5c, 0x4e, 0xe2, 0xe5, 0xa4, 0x1b, 0x4e, 0x4e, - 0xfe, 0x7a, 0x04, 0x30, 0x16, 0x4b, 0x74, 0xc5, 0x7c, 0x4e, 0xba, 0x50, 0xe1, 0xef, 0x43, 0x66, - 0x6a, 0x6d, 0xad, 0xd3, 0x3a, 0xb5, 0xba, 0x6b, 0x61, 0x77, 0x23, 0xea, 0x8e, 0xdf, 0x87, 0x0c, - 0xa5, 0x8e, 0x7c, 0x01, 0x07, 0x21, 0x63, 0xd1, 0xc0, 0x36, 0x4b, 0x6d, 0xad, 0xa3, 0x63, 0x12, - 0x91, 0xc7, 0xd0, 0xe0, 0xde, 0x82, 0xc5, 0xdc, 0x5d, 0x84, 0x66, 0xb9, 0xad, 0x75, 0xca, 0xb8, - 0x49, 0x90, 0x21, 0xb4, 0xc2, 0xe5, 0x64, 0xee, 0xc5, 0x6f, 0x2f, 0x59, 0x1c, 0xbb, 0x6f, 0x98, - 0x59, 0x69, 0x6b, 0x9d, 0xe6, 0xe9, 0xd3, 0xfc, 0xfd, 0x9c, 0x8c, 0x16, 0x77, 0x58, 0x32, 0x80, - 0xc3, 0x88, 0xbd, 0x63, 0x53, 0x9e, 0x16, 0xab, 0xca, 0x62, 0x5f, 0xe7, 0x17, 0xc3, 0x6d, 0x29, - 0x66, 0x49, 0x82, 0x60, 0xcc, 0x96, 0xe1, 0xdc, 0x9b, 0xba, 0x9c, 0xa5, 0xd5, 0x0e, 0x64, 0xb5, - 0x67, 0xf9, 0xd5, 0xec, 0x1d, 0x35, 0x7e, 0xc0, 0x8b, 0x66, 0x67, 0x6c, 0xee, 0xad, 0x58, 0x94, - 0x56, 0xac, 0x15, 0x35, 0x6b, 0x67, 0xb4, 0xb8, 0xc3, 0x92, 0x17, 0x50, 0x73, 0x67, 0x33, 0x87, - 0xb1, 0xc8, 0xac, 0xcb, 0x32, 0x4f, 0xf2, 0xcb, 0xf4, 0x94, 0x08, 0x53, 0x35, 0xf9, 0x1e, 0x20, - 0x62, 0x8b, 0x60, 0xc5, 0x24, 0xdb, 0x90, 0x6c, 0x7b, 0xdf, 0x15, 0xa5, 0x3a, 0xdc, 0x62, 0xc4, - 0xd6, 0x11, 0x9b, 0xae, 0xd0, 0xe9, 0x9b, 0x50, 0xb4, 0x35, 0x2a, 0x11, 0xa6, 0x6a, 0x01, 0xc6, - 0xcc, 0x9f, 0x09, 0xb0, 0x59, 0x04, 0x8e, 0x94, 0x08, 0x53, 0xb5, 0x00, 0x67, 0x51, 0x10, 0x0a, - 0x50, 0x2f, 0x02, 0x6d, 0x25, 0xc2, 0x54, 0x2d, 0x6c, 0xfc, 0x2e, 0xf0, 0x7c, 0xf3, 0x50, 0x52, - 0x7b, 0x6c, 0x7c, 0x11, 0x78, 0x3e, 0x4a, 0x1d, 0x79, 0x0e, 0xd5, 0x39, 0x73, 0x57, 0xcc, 0x6c, - 0x49, 0xe0, 0xcb, 0x7c, 0x60, 0x28, 0x24, 0xa8, 0x94, 0x02, 0x79, 0x13, 0xb9, 0x3f, 0x71, 0xf3, - 0xa8, 0x08, 0x39, 0x13, 0x12, 0x54, 0x4a, 0x81, 0x84, 0xd1, 0xd2, 0x67, 0xa6, 0x51, 0x84, 0x38, - 0x42, 0x82, 0x4a, 0x69, 0x75, 0xa1, 0x95, 0x75, 0xbf, 0x98, 0xac, 0x85, 0xfa, 0x1c, 0xd8, 0x72, - 0x4c, 0x75, 0xdc, 0x24, 0x2c, 0x0f, 0x0e, 0x33, 0x06, 0x2f, 0x96, 0x93, 0x13, 0xd0, 0x23, 0x36, - 0x65, 0xde, 0x8a, 0xcd, 0x5e, 0x47, 0xc1, 0x22, 0x19, 0xe2, 0x4c, 0x4e, 0x8c, 0x78, 0xc4, 0xdc, - 0x38, 0xf0, 0xe5, 0x1c, 0x37, 0x30, 0x89, 0xac, 0x31, 0x18, 0xbb, 0xee, 0xff, 0xef, 0xbb, 0x89, - 0x86, 0xb3, 0x13, 0xf0, 0x40, 0xc3, 0x2f, 0xa0, 0x96, 0x58, 0x7d, 0xeb, 0x2d, 0xd2, 0x32, 0x6f, - 0xd1, 0x23, 0x71, 0xed, 0x01, 0x0f, 0xe4, 0x7e, 0x0d, 0x54, 0x81, 0xf5, 0x14, 0x60, 0xe3, 0xf3, - 0x7d, 0xac, 0xf5, 0x23, 0xd4, 0x12, 0x3b, 0x7f, 0x70, 0x7a, 0x2d, 0xe7, 0xae, 0x9e, 0x43, 0x65, - 0xc1, 0xb8, 0x2b, 0x77, 0xda, 0x3f, 0x1f, 0x4e, 0xff, 0x92, 0x71, 0x17, 0xa5, 0xd4, 0x1a, 0x43, - 0x2d, 0xf1, 0xbd, 0x38, 0x84, 0x70, 0xfe, 0x38, 0x48, 0x0f, 0xa1, 0xa2, 0x7f, 0x59, 0x35, 0x19, - 0x8a, 0xff, 0xb3, 0xea, 0x63, 0xa8, 0x88, 0xa1, 0x11, 0x37, 0xca, 0x83, 0xd0, 0x9b, 0xca, 0x8a, - 0x0d, 0x54, 0x81, 0xf5, 0x04, 0xaa, 0x72, 0x42, 0x36, 0xcb, 0xa5, 0xed, 0xe5, 0x6f, 0xa0, 0x2a, - 0xa7, 0xa1, 0xe8, 0xef, 0x94, 0x8f, 0xc9, 0x89, 0xf8, 0x87, 0xd8, 0xaf, 0x1a, 0xd4, 0x92, 0xc3, - 0x93, 0x63, 0x80, 0xb5, 0x61, 0x62, 0x53, 0x6b, 0x97, 0x3b, 0x3a, 0x6e, 0x65, 0x48, 0x0f, 0xf4, - 0x78, 0x39, 0x89, 0xa7, 0x91, 0x17, 0x72, 0x2f, 0xf0, 0xcd, 0x52, 0xbb, 0x5c, 0xf0, 0x48, 0x2d, - 0x27, 0xf2, 0x46, 0x32, 0x08, 0xf9, 0x16, 0x6a, 0xd3, 0xc0, 0xe7, 0x51, 0x30, 0x97, 0x53, 0xd2, - 0x3c, 0xfd, 0x2a, 0x9f, 0xee, 0x2b, 0x91, 0xac, 0x90, 0x12, 0xd6, 0x77, 0x50, 0x4b, 0xaa, 0x0a, - 0xb3, 0x27, 0x75, 0x27, 0xea, 0x9f, 0x70, 0x1d, 0x37, 0x89, 0x3d, 0xad, 0xfe, 0x52, 0x82, 0xe6, - 0x56, 0x5d, 0xf2, 0x12, 0xaa, 0xde, 0x5b, 0xf1, 0x98, 0x69, 0xb2, 0x8f, 0x67, 0x85, 0x27, 0x19, - 0x9c, 0xbb, 0x2b, 0x26, 0x8f, 0xa3, 0x20, 0x49, 0xff, 0xec, 0xfa, 0x3c, 0xb9, 0x85, 0x07, 0xe8, - 0x1f, 0x5c, 0x9f, 0x27, 0xb4, 0x80, 0x04, 0xad, 0x5e, 0xc5, 0xf2, 0x47, 0xd0, 0xd2, 0x0e, 0x8a, - 0x56, 0x0f, 0xe4, 0xcb, 0xf4, 0x81, 0xac, 0x7c, 0x04, 0x2d, 0x5d, 0xa1, 0x68, 0xf5, 0x56, 0x9e, - 0x83, 0xb1, 0xdb, 0x54, 0xbe, 0x53, 0x77, 0x0c, 0x51, 0xda, 0x35, 0x84, 0x75, 0xba, 0xa9, 0x94, - 0x36, 0xf8, 0x90, 0x89, 0xac, 0xce, 0x9a, 0x59, 0xb7, 0xb5, 0x67, 0x4e, 0x36, 0xca, 0x75, 0x0b, - 0xf9, 0xca, 0x93, 0xdf, 0x35, 0xa8, 0x88, 0x1f, 0x5b, 0xe4, 0x33, 0x38, 0x72, 0x6e, 0x5e, 0x0d, - 0x07, 0xa3, 0xf3, 0xbb, 0x4b, 0x3a, 0x1a, 0xf5, 0xce, 0xa8, 0xf1, 0x09, 0x21, 0xd0, 0x42, 0x7a, - 0x41, 0xfb, 0xe3, 0x75, 0x4e, 0x23, 0x9f, 0xc3, 0xa7, 0xf6, 0x8d, 0x33, 0x1c, 0xf4, 0x7b, 0x63, - 0xba, 0x4e, 0x97, 0x04, 0x6f, 0xd3, 0xe1, 0xe0, 0x96, 0xe2, 0x3a, 0x59, 0x26, 0x3a, 0xd4, 0x7b, - 0xb6, 0x7d, 0xe7, 0x50, 0x8a, 0x46, 0x85, 0x1c, 0x41, 0x13, 0xe9, 0xe5, 0xf5, 0x2d, 0x55, 0x89, - 0xaa, 0x58, 0x46, 0xda, 0xbf, 0xbd, 0x43, 0xa7, 0x6f, 0x1c, 0x88, 0x68, 0x44, 0xaf, 0x6c, 0x19, - 0xd5, 0x44, 0x64, 0xe3, 0xb5, 0x23, 0xa3, 0x3a, 0xa9, 0x43, 0xe5, 0xe2, 0x7a, 0x70, 0x65, 0x34, - 0x48, 0x03, 0xaa, 0x43, 0xda, 0xbb, 0xa5, 0x06, 0x88, 0xcf, 0x33, 0xec, 0xbd, 0x1e, 0x1b, 0x4d, - 0xf1, 0xe9, 0xe0, 0xcd, 0x15, 0x35, 0xf4, 0x57, 0xfa, 0x6f, 0xf7, 0xc7, 0xda, 0x1f, 0xf7, 0xc7, - 0xda, 0x9f, 0xf7, 0xc7, 0xda, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf8, 0x22, 0x93, 0xfa, 0x95, - 0x0a, 0x00, 0x00, +var fileDescriptor_trace_f5041bb48e7a4810 = []byte{ + // 958 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xcf, 0x6e, 0xdb, 0x46, + 0x10, 0xc6, 0x4b, 0xfd, 0x31, 0xc5, 0x11, 0x2d, 0xb3, 0xdb, 0xa6, 0x20, 0xd8, 0xc4, 0x50, 0xdd, + 0x20, 0xd0, 0x49, 0x40, 0x0c, 0x14, 0x39, 0x34, 0x01, 0xaa, 0x88, 0xb4, 0x2d, 0x43, 0xb6, 0x89, + 0x91, 0xac, 0x1e, 0x5d, 0x4a, 0xda, 0x26, 0x0c, 0x24, 0x92, 0x20, 0x29, 0x15, 0x79, 0x80, 0xbe, + 0x5b, 0x6e, 0xed, 0x23, 0x14, 0x3e, 0xf5, 0x31, 0x8a, 0xdd, 0x25, 0x29, 0x51, 0xa6, 0x98, 0x34, + 0xed, 0x8d, 0xb3, 0xfc, 0x7e, 0xb3, 0x3b, 0xcb, 0xf9, 0x06, 0x84, 0x66, 0x1c, 0x3a, 0x33, 0xda, + 0x0d, 0x42, 0x3f, 0xf6, 0x89, 0x12, 0xac, 0xa6, 0xd1, 0x6a, 0xda, 0x0d, 0xa6, 0x27, 0x7f, 0x3f, + 0x02, 0x18, 0xb3, 0x57, 0xd6, 0x9a, 0x7a, 0x31, 0xe9, 0x42, 0x2d, 0x7e, 0x1f, 0x50, 0x5d, 0x6a, + 0x4b, 0x9d, 0xd6, 0xa9, 0xd1, 0xcd, 0x84, 0xdd, 0x8d, 0xa8, 0x3b, 0x7e, 0x1f, 0x50, 0xe4, 0x3a, + 0xf2, 0x0d, 0x1c, 0x04, 0x94, 0x86, 0x03, 0x53, 0xaf, 0xb4, 0xa5, 0x8e, 0x8a, 0x49, 0x44, 0x1e, + 0x83, 0x12, 0xbb, 0x4b, 0x1a, 0xc5, 0xce, 0x32, 0xd0, 0xab, 0x6d, 0xa9, 0x53, 0xc5, 0xcd, 0x02, + 0x19, 0x42, 0x2b, 0x58, 0x4d, 0x17, 0x6e, 0xf4, 0xf6, 0x8a, 0x46, 0x91, 0xf3, 0x86, 0xea, 0xb5, + 0xb6, 0xd4, 0x69, 0x9e, 0x3e, 0x2d, 0xde, 0xcf, 0xce, 0x69, 0x71, 0x87, 0x25, 0x03, 0x38, 0x0c, + 0xe9, 0x3b, 0x3a, 0x8b, 0xd3, 0x64, 0x75, 0x9e, 0xec, 0xfb, 0xe2, 0x64, 0xb8, 0x2d, 0xc5, 0x3c, + 0x49, 0x10, 0xb4, 0xf9, 0x2a, 0x58, 0xb8, 0x33, 0x27, 0xa6, 0x69, 0xb6, 0x03, 0x9e, 0xed, 0x59, + 0x71, 0x36, 0x73, 0x47, 0x8d, 0x0f, 0x78, 0x56, 0xec, 0x9c, 0x2e, 0xdc, 0x35, 0x0d, 0xd3, 0x8c, + 0x72, 0x59, 0xb1, 0x66, 0x4e, 0x8b, 0x3b, 0x2c, 0x79, 0x01, 0xb2, 0x33, 0x9f, 0xdb, 0x94, 0x86, + 0x7a, 0x83, 0xa7, 0x79, 0x52, 0x9c, 0xa6, 0x27, 0x44, 0x98, 0xaa, 0xc9, 0x4f, 0x00, 0x21, 0x5d, + 0xfa, 0x6b, 0xca, 0x59, 0x85, 0xb3, 0xed, 0x7d, 0x57, 0x94, 0xea, 0x70, 0x8b, 0x61, 0x5b, 0x87, + 0x74, 0xb6, 0x46, 0xbb, 0xaf, 0x43, 0xd9, 0xd6, 0x28, 0x44, 0x98, 0xaa, 0x19, 0x18, 0x51, 0x6f, + 0xce, 0xc0, 0x66, 0x19, 0x38, 0x12, 0x22, 0x4c, 0xd5, 0x0c, 0x9c, 0x87, 0x7e, 0xc0, 0x40, 0xb5, + 0x0c, 0x34, 0x85, 0x08, 0x53, 0x35, 0x6b, 0xe3, 0x77, 0xbe, 0xeb, 0xe9, 0x87, 0x9c, 0xda, 0xd3, + 0xc6, 0x97, 0xbe, 0xeb, 0x21, 0xd7, 0x91, 0xe7, 0x50, 0x5f, 0x50, 0x67, 0x4d, 0xf5, 0x16, 0x07, + 0xbe, 0x2d, 0x06, 0x86, 0x4c, 0x82, 0x42, 0xc9, 0x90, 0x37, 0xa1, 0xf3, 0x6b, 0xac, 0x1f, 0x95, + 0x21, 0xe7, 0x4c, 0x82, 0x42, 0xc9, 0x90, 0x20, 0x5c, 0x79, 0x54, 0xd7, 0xca, 0x10, 0x9b, 0x49, + 0x50, 0x28, 0x8d, 0x33, 0x68, 0xe5, 0xbb, 0x9f, 0x39, 0x6b, 0x29, 0x1e, 0x07, 0x26, 0xb7, 0xa9, + 0x8a, 0x9b, 0x05, 0xe6, 0xc7, 0xd8, 0x0f, 0xdc, 0x59, 0xa4, 0x57, 0xda, 0xd5, 0x8e, 0x82, 0x49, + 0x64, 0xb8, 0x70, 0x98, 0x6b, 0xfc, 0x8f, 0xa4, 0x39, 0x01, 0x35, 0xa4, 0x33, 0xea, 0xae, 0xe9, + 0xfc, 0x2c, 0xf4, 0x97, 0x89, 0xb9, 0x73, 0x6b, 0x6c, 0xab, 0x90, 0x3a, 0x91, 0xef, 0x71, 0x7f, + 0x2b, 0x98, 0x44, 0xc6, 0x18, 0xb4, 0x5d, 0x57, 0xfc, 0xf7, 0xdd, 0x8c, 0x2e, 0xb4, 0xf2, 0xce, + 0x28, 0xcf, 0x69, 0xbc, 0x00, 0x39, 0xb1, 0xc0, 0xd6, 0x8c, 0x92, 0x72, 0x33, 0xea, 0x6b, 0xf6, + 0x39, 0xfc, 0xd8, 0xe7, 0xfb, 0x29, 0x28, 0x02, 0xe3, 0x29, 0xc0, 0xa6, 0xff, 0xf7, 0xb1, 0xc6, + 0x2f, 0x20, 0x27, 0x6d, 0xfe, 0xe0, 0xf4, 0x52, 0xc1, 0x5d, 0x3d, 0x87, 0xda, 0x92, 0xc6, 0x0e, + 0xdf, 0x69, 0xbf, 0x6f, 0xec, 0xfe, 0x15, 0x8d, 0x1d, 0xe4, 0x52, 0x63, 0x0c, 0x72, 0xe2, 0x07, + 0x76, 0x08, 0xe6, 0x88, 0xb1, 0x9f, 0x1e, 0x42, 0x44, 0x9f, 0x99, 0x35, 0x31, 0xcb, 0xff, 0x99, + 0xf5, 0x31, 0xd4, 0x98, 0x99, 0xd8, 0x8d, 0xf2, 0x7e, 0xe3, 0x19, 0x15, 0x14, 0x81, 0xf1, 0x04, + 0xea, 0xdc, 0x39, 0x9b, 0xd7, 0x95, 0xed, 0xd7, 0x3f, 0x40, 0x9d, 0xbb, 0xa4, 0xec, 0x3b, 0x15, + 0x63, 0xdc, 0x29, 0xff, 0x12, 0xfb, 0x20, 0x81, 0x9c, 0x1c, 0x9e, 0xbc, 0x82, 0x46, 0xd2, 0x30, + 0x91, 0x2e, 0xb5, 0xab, 0x9d, 0xe6, 0xe9, 0x77, 0xc5, 0xd5, 0x26, 0x2d, 0xc7, 0x2b, 0xce, 0x10, + 0xd2, 0x03, 0x35, 0x5a, 0x4d, 0xa3, 0x59, 0xe8, 0x06, 0xb1, 0xeb, 0x7b, 0xdc, 0x71, 0xfb, 0x67, + 0xdb, 0x6a, 0xca, 0xf1, 0x1c, 0x42, 0x7e, 0x04, 0x79, 0xe6, 0x7b, 0x71, 0xe8, 0x2f, 0xb8, 0x89, + 0xf6, 0x1e, 0xa0, 0x2f, 0x44, 0x3c, 0x43, 0x4a, 0x18, 0x7d, 0x68, 0x6e, 0x1d, 0xec, 0x33, 0x07, + 0xc3, 0x2b, 0x90, 0x93, 0xa3, 0xb1, 0x04, 0xc9, 0xe1, 0xa6, 0xe2, 0x07, 0xa0, 0x81, 0x9b, 0x85, + 0x3d, 0xd7, 0xf9, 0x7b, 0x05, 0x9a, 0x5b, 0x87, 0x23, 0x2f, 0xa1, 0xee, 0xbe, 0x65, 0x83, 0x54, + 0xdc, 0xe7, 0xb3, 0xd2, 0x72, 0x06, 0x17, 0xce, 0x5a, 0x5c, 0xaa, 0x80, 0x38, 0xfd, 0x9b, 0xe3, + 0xc5, 0xc9, 0x55, 0x7e, 0x84, 0xfe, 0xd9, 0xf1, 0xe2, 0x84, 0x66, 0x10, 0xa3, 0xc5, 0x44, 0xae, + 0x7e, 0x02, 0xcd, 0x5b, 0x4e, 0xd0, 0x62, 0x38, 0xbf, 0x4c, 0x87, 0x73, 0xed, 0x13, 0x68, 0xde, + 0x79, 0x82, 0x16, 0x73, 0xfa, 0x02, 0xb4, 0xdd, 0xa2, 0x8a, 0xdd, 0x40, 0x8e, 0x01, 0xb2, 0xaf, + 0x22, 0x3e, 0x86, 0x8a, 0x5b, 0x2b, 0xc6, 0xe9, 0x26, 0x53, 0x5a, 0xe0, 0x0e, 0x23, 0x3d, 0x60, + 0x3a, 0x19, 0x93, 0x95, 0xb5, 0xc7, 0x8b, 0x1b, 0x65, 0x56, 0x42, 0xb1, 0xf2, 0xe4, 0x0f, 0x09, + 0x6a, 0xec, 0x47, 0x8f, 0x7c, 0x05, 0x47, 0xf6, 0xed, 0xeb, 0xe1, 0x60, 0x74, 0x71, 0x77, 0x65, + 0x8d, 0x46, 0xbd, 0x73, 0x4b, 0xfb, 0x82, 0x10, 0x68, 0xa1, 0x75, 0x69, 0xf5, 0xc7, 0xd9, 0x9a, + 0x44, 0x1e, 0xc1, 0x97, 0xe6, 0xad, 0x3d, 0x1c, 0xf4, 0x7b, 0x63, 0x2b, 0x5b, 0xae, 0x30, 0xde, + 0xb4, 0x86, 0x83, 0x89, 0x85, 0xd9, 0x62, 0x95, 0xa8, 0xd0, 0xe8, 0x99, 0xe6, 0x9d, 0x6d, 0x59, + 0xa8, 0xd5, 0xc8, 0x11, 0x34, 0xd1, 0xba, 0xba, 0x99, 0x58, 0x62, 0xa1, 0xce, 0x5e, 0xa3, 0xd5, + 0x9f, 0xdc, 0xa1, 0xdd, 0xd7, 0x0e, 0x58, 0x34, 0xb2, 0xae, 0x4d, 0x1e, 0xc9, 0x2c, 0x32, 0xf1, + 0xc6, 0xe6, 0x51, 0x83, 0x34, 0xa0, 0x76, 0x79, 0x33, 0xb8, 0xd6, 0x14, 0xa2, 0x40, 0x7d, 0x68, + 0xf5, 0x26, 0x96, 0x06, 0xec, 0xf1, 0x1c, 0x7b, 0x67, 0x63, 0xad, 0xc9, 0x1e, 0x6d, 0xbc, 0xbd, + 0xb6, 0x34, 0xf5, 0xb5, 0xfa, 0xe1, 0xfe, 0x58, 0xfa, 0xf3, 0xfe, 0x58, 0xfa, 0xeb, 0xfe, 0x58, + 0xfa, 0x27, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x5e, 0x59, 0x8a, 0x11, 0x0b, 0x00, 0x00, } diff --git a/pb/trace.proto b/pb/trace.proto index 3659c5a..e6369ed 100644 --- a/pb/trace.proto +++ b/pb/trace.proto @@ -39,6 +39,7 @@ message TraceEvent { message PublishMessage { optional bytes messageID = 1; + repeated string topics = 2; } message RejectMessage { @@ -99,11 +100,16 @@ message TraceEvent { } message RPCMeta { - repeated bytes messageIDs = 1; + repeated MessageMeta messages = 1; repeated SubMeta subscription = 2; optional ControlMeta control = 3; } + message MessageMeta { + optional bytes messageID = 1; + repeated string topics = 2; + } + message SubMeta { optional bool subscribe = 1; optional string topic = 2; diff --git a/trace.go b/trace.go index af0fc03..eecd638 100644 --- a/trace.go +++ b/trace.go @@ -31,6 +31,7 @@ func (t *pubsubTracer) PublishMessage(msg *Message) { Timestamp: &now, PublishMessage: &pb.TraceEvent_PublishMessage{ MessageID: []byte(msgID(msg.Message)), + Topics: msg.Message.TopicIDs, }, } @@ -192,11 +193,14 @@ func (t *pubsubTracer) DropRPC(rpc *RPC, p peer.ID) { func traceRPCMeta(rpc *RPC) *pb.TraceEvent_RPCMeta { rpcMeta := new(pb.TraceEvent_RPCMeta) - var mids [][]byte + var msgs []*pb.TraceEvent_MessageMeta for _, m := range rpc.Publish { - mids = append(mids, []byte(msgID(m))) + msgs = append(msgs, &pb.TraceEvent_MessageMeta{ + MessageID: []byte(msgID(m)), + Topics: m.TopicIDs, + }) } - rpcMeta.MessageIDs = mids + rpcMeta.Messages = msgs var subs []*pb.TraceEvent_SubMeta for _, sub := range rpc.Subscriptions { From 3545acf0298d5fdc785609afbdf192a51ed845ff Mon Sep 17 00:00:00 2001 From: vyzo Date: Tue, 12 Nov 2019 15:05:40 +0200 Subject: [PATCH 11/25] json tracer --- trace.go | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) diff --git a/trace.go b/trace.go index eecd638..744c01e 100644 --- a/trace.go +++ b/trace.go @@ -1,6 +1,10 @@ package pubsub import ( + "encoding/json" + "io" + "os" + "sync" "time" "github.com/libp2p/go-libp2p-core/peer" @@ -14,6 +18,75 @@ type EventTracer interface { Trace(evt interface{}) } +// JSONTracer is a tracer that writes events to a file, encoded in json. +type JSONTracer struct { + w io.WriteCloser + ch chan struct{} + mx sync.Mutex + buf []interface{} +} + +// NewJsonTracer creates a new JSON tracer writing to file. +func NewJSONTracer(file string) (*JSONTracer, error) { + return OpenJSONTracer(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644) +} + +// OpenJsonTracer creates a new JSON tracer, with explicit control of OpenFile flags and permissions. +func OpenJSONTracer(file string, flags int, perm os.FileMode) (*JSONTracer, error) { + f, err := os.OpenFile(file, flags, perm) + if err != nil { + return nil, err + } + + tr := &JSONTracer{w: f, ch: make(chan struct{}, 1)} + go tr.doWrite() + + return tr, nil +} + +func (t *JSONTracer) Trace(evt interface{}) { + t.mx.Lock() + t.buf = append(t.buf, evt) + t.mx.Unlock() + + select { + case t.ch <- struct{}{}: + default: + } +} + +func (t *JSONTracer) Close() { + close(t.ch) +} + +func (t *JSONTracer) doWrite() { + var buf []interface{} + enc := json.NewEncoder(t.w) + for { + _, ok := <-t.ch + + t.mx.Lock() + tmp := t.buf + t.buf = buf[:0] + buf = tmp + t.mx.Unlock() + + for i, evt := range buf { + err := enc.Encode(evt) + if err != nil { + log.Errorf("error writing event trace: %s", err.Error()) + } + buf[i] = nil + } + + if !ok { + t.w.Close() + return + } + } +} + +// pubsub tracer details type pubsubTracer struct { tracer EventTracer pid peer.ID From 8ff321c529bb7eb369f4263b6f81d87dca04308c Mon Sep 17 00:00:00 2001 From: vyzo Date: Tue, 12 Nov 2019 20:24:24 +0200 Subject: [PATCH 12/25] move tracer implementation to its own file --- trace.go | 72 ---------------------------------------------------- tracer.go | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 76 insertions(+), 72 deletions(-) create mode 100644 tracer.go diff --git a/trace.go b/trace.go index 744c01e..5b3a558 100644 --- a/trace.go +++ b/trace.go @@ -1,10 +1,6 @@ package pubsub import ( - "encoding/json" - "io" - "os" - "sync" "time" "github.com/libp2p/go-libp2p-core/peer" @@ -18,74 +14,6 @@ type EventTracer interface { Trace(evt interface{}) } -// JSONTracer is a tracer that writes events to a file, encoded in json. -type JSONTracer struct { - w io.WriteCloser - ch chan struct{} - mx sync.Mutex - buf []interface{} -} - -// NewJsonTracer creates a new JSON tracer writing to file. -func NewJSONTracer(file string) (*JSONTracer, error) { - return OpenJSONTracer(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644) -} - -// OpenJsonTracer creates a new JSON tracer, with explicit control of OpenFile flags and permissions. -func OpenJSONTracer(file string, flags int, perm os.FileMode) (*JSONTracer, error) { - f, err := os.OpenFile(file, flags, perm) - if err != nil { - return nil, err - } - - tr := &JSONTracer{w: f, ch: make(chan struct{}, 1)} - go tr.doWrite() - - return tr, nil -} - -func (t *JSONTracer) Trace(evt interface{}) { - t.mx.Lock() - t.buf = append(t.buf, evt) - t.mx.Unlock() - - select { - case t.ch <- struct{}{}: - default: - } -} - -func (t *JSONTracer) Close() { - close(t.ch) -} - -func (t *JSONTracer) doWrite() { - var buf []interface{} - enc := json.NewEncoder(t.w) - for { - _, ok := <-t.ch - - t.mx.Lock() - tmp := t.buf - t.buf = buf[:0] - buf = tmp - t.mx.Unlock() - - for i, evt := range buf { - err := enc.Encode(evt) - if err != nil { - log.Errorf("error writing event trace: %s", err.Error()) - } - buf[i] = nil - } - - if !ok { - t.w.Close() - return - } - } -} - // pubsub tracer details type pubsubTracer struct { tracer EventTracer diff --git a/tracer.go b/tracer.go new file mode 100644 index 0000000..efa2ac6 --- /dev/null +++ b/tracer.go @@ -0,0 +1,76 @@ +package pubsub + +import ( + "encoding/json" + "io" + "os" + "sync" +) + +// JSONTracer is a tracer that writes events to a file, encoded in json. +type JSONTracer struct { + w io.WriteCloser + ch chan struct{} + mx sync.Mutex + buf []interface{} +} + +// NewJsonTracer creates a new JSON tracer writing to file. +func NewJSONTracer(file string) (*JSONTracer, error) { + return OpenJSONTracer(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644) +} + +// OpenJsonTracer creates a new JSON tracer, with explicit control of OpenFile flags and permissions. +func OpenJSONTracer(file string, flags int, perm os.FileMode) (*JSONTracer, error) { + f, err := os.OpenFile(file, flags, perm) + if err != nil { + return nil, err + } + + tr := &JSONTracer{w: f, ch: make(chan struct{}, 1)} + go tr.doWrite() + + return tr, nil +} + +func (t *JSONTracer) Trace(evt interface{}) { + t.mx.Lock() + t.buf = append(t.buf, evt) + t.mx.Unlock() + + select { + case t.ch <- struct{}{}: + default: + } +} + +func (t *JSONTracer) Close() { + close(t.ch) +} + +func (t *JSONTracer) doWrite() { + var buf []interface{} + enc := json.NewEncoder(t.w) + for { + _, ok := <-t.ch + + t.mx.Lock() + tmp := t.buf + t.buf = buf[:0] + buf = tmp + t.mx.Unlock() + + for i, evt := range buf { + err := enc.Encode(evt) + if err != nil { + log.Errorf("error writing event trace: %s", err.Error()) + } + buf[i] = nil + } + + if !ok { + t.w.Close() + return + } + } +} From f134d6584880a05e7cf87d9ba01a838e6f39a412 Mon Sep 17 00:00:00 2001 From: vyzo Date: Tue, 12 Nov 2019 21:50:39 +0200 Subject: [PATCH 13/25] add protobuf file tracer --- tracer.go | 108 ++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 85 insertions(+), 23 deletions(-) diff --git a/tracer.go b/tracer.go index efa2ac6..fe6e47f 100644 --- a/tracer.go +++ b/tracer.go @@ -5,35 +5,19 @@ import ( "io" "os" "sync" + + ggio "github.com/gogo/protobuf/io" + + pb "github.com/libp2p/go-libp2p-pubsub/pb" ) -// JSONTracer is a tracer that writes events to a file, encoded in json. -type JSONTracer struct { - w io.WriteCloser +type basicTracer struct { ch chan struct{} mx sync.Mutex buf []interface{} } -// NewJsonTracer creates a new JSON tracer writing to file. -func NewJSONTracer(file string) (*JSONTracer, error) { - return OpenJSONTracer(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644) -} - -// OpenJsonTracer creates a new JSON tracer, with explicit control of OpenFile flags and permissions. -func OpenJSONTracer(file string, flags int, perm os.FileMode) (*JSONTracer, error) { - f, err := os.OpenFile(file, flags, perm) - if err != nil { - return nil, err - } - - tr := &JSONTracer{w: f, ch: make(chan struct{}, 1)} - go tr.doWrite() - - return tr, nil -} - -func (t *JSONTracer) Trace(evt interface{}) { +func (t *basicTracer) Trace(evt interface{}) { t.mx.Lock() t.buf = append(t.buf, evt) t.mx.Unlock() @@ -44,10 +28,34 @@ func (t *JSONTracer) Trace(evt interface{}) { } } -func (t *JSONTracer) Close() { +func (t *basicTracer) Close() { close(t.ch) } +// JSONTracer is a tracer that writes events to a file, encoded in ndjson. +type JSONTracer struct { + basicTracer + w io.WriteCloser +} + +// NewJsonTracer creates a new JSONTracer writing traces to file. +func NewJSONTracer(file string) (*JSONTracer, error) { + return OpenJSONTracer(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644) +} + +// OpenJSONTracer creates a new JSONTracer, with explicit control of OpenFile flags and permissions. +func OpenJSONTracer(file string, flags int, perm os.FileMode) (*JSONTracer, error) { + f, err := os.OpenFile(file, flags, perm) + if err != nil { + return nil, err + } + + tr := &JSONTracer{w: f, basicTracer: basicTracer{ch: make(chan struct{}, 1)}} + go tr.doWrite() + + return tr, nil +} + func (t *JSONTracer) doWrite() { var buf []interface{} enc := json.NewEncoder(t.w) @@ -74,3 +82,57 @@ func (t *JSONTracer) doWrite() { } } } + +var _ EventTracer = (*JSONTracer)(nil) + +// PBTracer is a tracer that writes events to a file, as delimited protobufs. +type PBTracer struct { + basicTracer + w io.WriteCloser +} + +func NewPBTracer(file string) (*PBTracer, error) { + return OpenPBTracer(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644) +} + +// OpenPBTracer creates a new PBTracer, with explicit control of OpenFile flags and permissions. +func OpenPBTracer(file string, flags int, perm os.FileMode) (*PBTracer, error) { + f, err := os.OpenFile(file, flags, perm) + if err != nil { + return nil, err + } + + tr := &PBTracer{w: f, basicTracer: basicTracer{ch: make(chan struct{}, 1)}} + go tr.doWrite() + + return tr, nil +} + +func (t *PBTracer) doWrite() { + var buf []interface{} + w := ggio.NewDelimitedWriter(t.w) + for { + _, ok := <-t.ch + + t.mx.Lock() + tmp := t.buf + t.buf = buf[:0] + buf = tmp + t.mx.Unlock() + + for i, evt := range buf { + err := w.WriteMsg(evt.(*pb.TraceEvent)) + if err != nil { + log.Errorf("error writing event trace: %s", err.Error()) + } + buf[i] = nil + } + + if !ok { + t.w.Close() + return + } + } +} + +var _ EventTracer = (*PBTracer)(nil) From 0aa629c79cbea3146929fd787b12cc4941478e74 Mon Sep 17 00:00:00 2001 From: vyzo Date: Wed, 13 Nov 2019 12:22:40 +0200 Subject: [PATCH 14/25] use *pb.TraceEvent as argument for Trace in the EventTracer interface --- trace.go | 2 +- tracer.go | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/trace.go b/trace.go index 5b3a558..293f166 100644 --- a/trace.go +++ b/trace.go @@ -11,7 +11,7 @@ import ( // Generic event tracer interface type EventTracer interface { - Trace(evt interface{}) + Trace(evt *pb.TraceEvent) } // pubsub tracer details diff --git a/tracer.go b/tracer.go index fe6e47f..01b1ec6 100644 --- a/tracer.go +++ b/tracer.go @@ -14,10 +14,10 @@ import ( type basicTracer struct { ch chan struct{} mx sync.Mutex - buf []interface{} + buf []*pb.TraceEvent } -func (t *basicTracer) Trace(evt interface{}) { +func (t *basicTracer) Trace(evt *pb.TraceEvent) { t.mx.Lock() t.buf = append(t.buf, evt) t.mx.Unlock() @@ -57,7 +57,7 @@ func OpenJSONTracer(file string, flags int, perm os.FileMode) (*JSONTracer, erro } func (t *JSONTracer) doWrite() { - var buf []interface{} + var buf []*pb.TraceEvent enc := json.NewEncoder(t.w) for { _, ok := <-t.ch @@ -109,7 +109,7 @@ func OpenPBTracer(file string, flags int, perm os.FileMode) (*PBTracer, error) { } func (t *PBTracer) doWrite() { - var buf []interface{} + var buf []*pb.TraceEvent w := ggio.NewDelimitedWriter(t.w) for { _, ok := <-t.ch @@ -121,7 +121,7 @@ func (t *PBTracer) doWrite() { t.mx.Unlock() for i, evt := range buf { - err := w.WriteMsg(evt.(*pb.TraceEvent)) + err := w.WriteMsg(evt) if err != nil { log.Errorf("error writing event trace: %s", err.Error()) } From 57ea27eef7f309982f815a3ddb64eded6897bc7f Mon Sep 17 00:00:00 2001 From: vyzo Date: Thu, 14 Nov 2019 12:23:32 +0200 Subject: [PATCH 15/25] remote tracer --- pb/trace.pb.go | 529 +++++++++++++++++++++++++++++++++++++++++-------- pb/trace.proto | 8 + tracer.go | 163 ++++++++++++++- 3 files changed, 612 insertions(+), 88 deletions(-) diff --git a/pb/trace.pb.go b/pb/trace.pb.go index 00d4f45..b9b829d 100644 --- a/pb/trace.pb.go +++ b/pb/trace.pb.go @@ -86,7 +86,7 @@ func (x *TraceEvent_Type) UnmarshalJSON(data []byte) error { return nil } func (TraceEvent_Type) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 0} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 0} } type TraceEvent struct { @@ -115,7 +115,7 @@ func (m *TraceEvent) Reset() { *m = TraceEvent{} } func (m *TraceEvent) String() string { return proto.CompactTextString(m) } func (*TraceEvent) ProtoMessage() {} func (*TraceEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0} + return fileDescriptor_trace_a154d83c271edb68, []int{0} } func (m *TraceEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -268,7 +268,7 @@ func (m *TraceEvent_PublishMessage) Reset() { *m = TraceEvent_PublishMes func (m *TraceEvent_PublishMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_PublishMessage) ProtoMessage() {} func (*TraceEvent_PublishMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 0} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 0} } func (m *TraceEvent_PublishMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -324,7 +324,7 @@ func (m *TraceEvent_RejectMessage) Reset() { *m = TraceEvent_RejectMessa func (m *TraceEvent_RejectMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RejectMessage) ProtoMessage() {} func (*TraceEvent_RejectMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 1} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 1} } func (m *TraceEvent_RejectMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -386,7 +386,7 @@ func (m *TraceEvent_DuplicateMessage) Reset() { *m = TraceEvent_Duplicat func (m *TraceEvent_DuplicateMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DuplicateMessage) ProtoMessage() {} func (*TraceEvent_DuplicateMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 2} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 2} } func (m *TraceEvent_DuplicateMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -440,7 +440,7 @@ func (m *TraceEvent_DeliverMessage) Reset() { *m = TraceEvent_DeliverMes func (m *TraceEvent_DeliverMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DeliverMessage) ProtoMessage() {} func (*TraceEvent_DeliverMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 3} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 3} } func (m *TraceEvent_DeliverMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -488,7 +488,7 @@ func (m *TraceEvent_AddPeer) Reset() { *m = TraceEvent_AddPeer{} } func (m *TraceEvent_AddPeer) String() string { return proto.CompactTextString(m) } func (*TraceEvent_AddPeer) ProtoMessage() {} func (*TraceEvent_AddPeer) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 4} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 4} } func (m *TraceEvent_AddPeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -542,7 +542,7 @@ func (m *TraceEvent_RemovePeer) Reset() { *m = TraceEvent_RemovePeer{} } func (m *TraceEvent_RemovePeer) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RemovePeer) ProtoMessage() {} func (*TraceEvent_RemovePeer) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 5} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 5} } func (m *TraceEvent_RemovePeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -590,7 +590,7 @@ func (m *TraceEvent_RecvRPC) Reset() { *m = TraceEvent_RecvRPC{} } func (m *TraceEvent_RecvRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RecvRPC) ProtoMessage() {} func (*TraceEvent_RecvRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 6} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 6} } func (m *TraceEvent_RecvRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -645,7 +645,7 @@ func (m *TraceEvent_SendRPC) Reset() { *m = TraceEvent_SendRPC{} } func (m *TraceEvent_SendRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_SendRPC) ProtoMessage() {} func (*TraceEvent_SendRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 7} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 7} } func (m *TraceEvent_SendRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -700,7 +700,7 @@ func (m *TraceEvent_DropRPC) Reset() { *m = TraceEvent_DropRPC{} } func (m *TraceEvent_DropRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DropRPC) ProtoMessage() {} func (*TraceEvent_DropRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 8} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 8} } func (m *TraceEvent_DropRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -754,7 +754,7 @@ func (m *TraceEvent_Join) Reset() { *m = TraceEvent_Join{} } func (m *TraceEvent_Join) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Join) ProtoMessage() {} func (*TraceEvent_Join) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 9} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 9} } func (m *TraceEvent_Join) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -801,7 +801,7 @@ func (m *TraceEvent_Leave) Reset() { *m = TraceEvent_Leave{} } func (m *TraceEvent_Leave) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Leave) ProtoMessage() {} func (*TraceEvent_Leave) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 10} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 10} } func (m *TraceEvent_Leave) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -849,7 +849,7 @@ func (m *TraceEvent_Graft) Reset() { *m = TraceEvent_Graft{} } func (m *TraceEvent_Graft) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Graft) ProtoMessage() {} func (*TraceEvent_Graft) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 11} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 11} } func (m *TraceEvent_Graft) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -904,7 +904,7 @@ func (m *TraceEvent_Prune) Reset() { *m = TraceEvent_Prune{} } func (m *TraceEvent_Prune) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Prune) ProtoMessage() {} func (*TraceEvent_Prune) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 12} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 12} } func (m *TraceEvent_Prune) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -960,7 +960,7 @@ func (m *TraceEvent_RPCMeta) Reset() { *m = TraceEvent_RPCMeta{} } func (m *TraceEvent_RPCMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RPCMeta) ProtoMessage() {} func (*TraceEvent_RPCMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 13} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 13} } func (m *TraceEvent_RPCMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1022,7 +1022,7 @@ func (m *TraceEvent_MessageMeta) Reset() { *m = TraceEvent_MessageMeta{} func (m *TraceEvent_MessageMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_MessageMeta) ProtoMessage() {} func (*TraceEvent_MessageMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 14} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 14} } func (m *TraceEvent_MessageMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1077,7 +1077,7 @@ func (m *TraceEvent_SubMeta) Reset() { *m = TraceEvent_SubMeta{} } func (m *TraceEvent_SubMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_SubMeta) ProtoMessage() {} func (*TraceEvent_SubMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 15} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 15} } func (m *TraceEvent_SubMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1134,7 +1134,7 @@ func (m *TraceEvent_ControlMeta) Reset() { *m = TraceEvent_ControlMeta{} func (m *TraceEvent_ControlMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlMeta) ProtoMessage() {} func (*TraceEvent_ControlMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 16} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 16} } func (m *TraceEvent_ControlMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1203,7 +1203,7 @@ func (m *TraceEvent_ControlIHaveMeta) Reset() { *m = TraceEvent_ControlI func (m *TraceEvent_ControlIHaveMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlIHaveMeta) ProtoMessage() {} func (*TraceEvent_ControlIHaveMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 17} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 17} } func (m *TraceEvent_ControlIHaveMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1257,7 +1257,7 @@ func (m *TraceEvent_ControlIWantMeta) Reset() { *m = TraceEvent_ControlI func (m *TraceEvent_ControlIWantMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlIWantMeta) ProtoMessage() {} func (*TraceEvent_ControlIWantMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 18} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 18} } func (m *TraceEvent_ControlIWantMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1304,7 +1304,7 @@ func (m *TraceEvent_ControlGraftMeta) Reset() { *m = TraceEvent_ControlG func (m *TraceEvent_ControlGraftMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlGraftMeta) ProtoMessage() {} func (*TraceEvent_ControlGraftMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 19} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 19} } func (m *TraceEvent_ControlGraftMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1351,7 +1351,7 @@ func (m *TraceEvent_ControlPruneMeta) Reset() { *m = TraceEvent_ControlP func (m *TraceEvent_ControlPruneMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlPruneMeta) ProtoMessage() {} func (*TraceEvent_ControlPruneMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_f5041bb48e7a4810, []int{0, 20} + return fileDescriptor_trace_a154d83c271edb68, []int{0, 20} } func (m *TraceEvent_ControlPruneMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1387,6 +1387,100 @@ func (m *TraceEvent_ControlPruneMeta) GetTopic() string { return "" } +type TraceEventBatch struct { + Batch []*TraceEvent `protobuf:"bytes,1,rep,name=batch" json:"batch,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TraceEventBatch) Reset() { *m = TraceEventBatch{} } +func (m *TraceEventBatch) String() string { return proto.CompactTextString(m) } +func (*TraceEventBatch) ProtoMessage() {} +func (*TraceEventBatch) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_a154d83c271edb68, []int{1} +} +func (m *TraceEventBatch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceEventBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceEventBatch.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *TraceEventBatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEventBatch.Merge(dst, src) +} +func (m *TraceEventBatch) XXX_Size() int { + return m.Size() +} +func (m *TraceEventBatch) XXX_DiscardUnknown() { + xxx_messageInfo_TraceEventBatch.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceEventBatch proto.InternalMessageInfo + +func (m *TraceEventBatch) GetBatch() []*TraceEvent { + if m != nil { + return m.Batch + } + return nil +} + +type CompressedTraceEventBatch struct { + Data []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CompressedTraceEventBatch) Reset() { *m = CompressedTraceEventBatch{} } +func (m *CompressedTraceEventBatch) String() string { return proto.CompactTextString(m) } +func (*CompressedTraceEventBatch) ProtoMessage() {} +func (*CompressedTraceEventBatch) Descriptor() ([]byte, []int) { + return fileDescriptor_trace_a154d83c271edb68, []int{2} +} +func (m *CompressedTraceEventBatch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CompressedTraceEventBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CompressedTraceEventBatch.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *CompressedTraceEventBatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompressedTraceEventBatch.Merge(dst, src) +} +func (m *CompressedTraceEventBatch) XXX_Size() int { + return m.Size() +} +func (m *CompressedTraceEventBatch) XXX_DiscardUnknown() { + xxx_messageInfo_CompressedTraceEventBatch.DiscardUnknown(m) +} + +var xxx_messageInfo_CompressedTraceEventBatch proto.InternalMessageInfo + +func (m *CompressedTraceEventBatch) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + func init() { proto.RegisterType((*TraceEvent)(nil), "pubsub.pb.TraceEvent") proto.RegisterType((*TraceEvent_PublishMessage)(nil), "pubsub.pb.TraceEvent.PublishMessage") @@ -1410,6 +1504,8 @@ func init() { proto.RegisterType((*TraceEvent_ControlIWantMeta)(nil), "pubsub.pb.TraceEvent.ControlIWantMeta") proto.RegisterType((*TraceEvent_ControlGraftMeta)(nil), "pubsub.pb.TraceEvent.ControlGraftMeta") proto.RegisterType((*TraceEvent_ControlPruneMeta)(nil), "pubsub.pb.TraceEvent.ControlPruneMeta") + proto.RegisterType((*TraceEventBatch)(nil), "pubsub.pb.TraceEventBatch") + proto.RegisterType((*CompressedTraceEventBatch)(nil), "pubsub.pb.CompressedTraceEventBatch") proto.RegisterEnum("pubsub.pb.TraceEvent_Type", TraceEvent_Type_name, TraceEvent_Type_value) } func (m *TraceEvent) Marshal() (dAtA []byte, err error) { @@ -2334,6 +2430,66 @@ func (m *TraceEvent_ControlPruneMeta) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *TraceEventBatch) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEventBatch) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Batch) > 0 { + for _, msg := range m.Batch { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CompressedTraceEventBatch) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CompressedTraceEventBatch) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Data != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintTrace(dAtA, i, uint64(len(m.Data))) + i += copy(dAtA[i:], m.Data) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + func encodeVarintTrace(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -2844,6 +3000,40 @@ func (m *TraceEvent_ControlPruneMeta) Size() (n int) { return n } +func (m *TraceEventBatch) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Batch) > 0 { + for _, e := range m.Batch { + l = e.Size() + n += 1 + l + sovTrace(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CompressedTraceEventBatch) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = len(m.Data) + n += 1 + l + sovTrace(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovTrace(x uint64) (n int) { for { n++ @@ -5668,6 +5858,170 @@ func (m *TraceEvent_ControlPruneMeta) Unmarshal(dAtA []byte) error { } return nil } +func (m *TraceEventBatch) 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 ErrIntOverflowTrace + } + 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: TraceEventBatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TraceEventBatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Batch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Batch = append(m.Batch, &TraceEvent{}) + if err := m.Batch[len(m.Batch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CompressedTraceEventBatch) 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 ErrIntOverflowTrace + } + 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: CompressedTraceEventBatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CompressedTraceEventBatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTrace + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTrace + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTrace(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTrace + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTrace(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 @@ -5773,68 +6127,71 @@ var ( ErrIntOverflowTrace = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("trace.proto", fileDescriptor_trace_f5041bb48e7a4810) } +func init() { proto.RegisterFile("trace.proto", fileDescriptor_trace_a154d83c271edb68) } -var fileDescriptor_trace_f5041bb48e7a4810 = []byte{ - // 958 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xcf, 0x6e, 0xdb, 0x46, - 0x10, 0xc6, 0x4b, 0xfd, 0x31, 0xc5, 0x11, 0x2d, 0xb3, 0xdb, 0xa6, 0x20, 0xd8, 0xc4, 0x50, 0xdd, - 0x20, 0xd0, 0x49, 0x40, 0x0c, 0x14, 0x39, 0x34, 0x01, 0xaa, 0x88, 0xb4, 0x2d, 0x43, 0xb6, 0x89, - 0x91, 0xac, 0x1e, 0x5d, 0x4a, 0xda, 0x26, 0x0c, 0x24, 0x92, 0x20, 0x29, 0x15, 0x79, 0x80, 0xbe, - 0x5b, 0x6e, 0xed, 0x23, 0x14, 0x3e, 0xf5, 0x31, 0x8a, 0xdd, 0x25, 0x29, 0x51, 0xa6, 0x98, 0x34, - 0xed, 0x8d, 0xb3, 0xfc, 0x7e, 0xb3, 0x3b, 0xcb, 0xf9, 0x06, 0x84, 0x66, 0x1c, 0x3a, 0x33, 0xda, - 0x0d, 0x42, 0x3f, 0xf6, 0x89, 0x12, 0xac, 0xa6, 0xd1, 0x6a, 0xda, 0x0d, 0xa6, 0x27, 0x7f, 0x3f, - 0x02, 0x18, 0xb3, 0x57, 0xd6, 0x9a, 0x7a, 0x31, 0xe9, 0x42, 0x2d, 0x7e, 0x1f, 0x50, 0x5d, 0x6a, - 0x4b, 0x9d, 0xd6, 0xa9, 0xd1, 0xcd, 0x84, 0xdd, 0x8d, 0xa8, 0x3b, 0x7e, 0x1f, 0x50, 0xe4, 0x3a, - 0xf2, 0x0d, 0x1c, 0x04, 0x94, 0x86, 0x03, 0x53, 0xaf, 0xb4, 0xa5, 0x8e, 0x8a, 0x49, 0x44, 0x1e, - 0x83, 0x12, 0xbb, 0x4b, 0x1a, 0xc5, 0xce, 0x32, 0xd0, 0xab, 0x6d, 0xa9, 0x53, 0xc5, 0xcd, 0x02, - 0x19, 0x42, 0x2b, 0x58, 0x4d, 0x17, 0x6e, 0xf4, 0xf6, 0x8a, 0x46, 0x91, 0xf3, 0x86, 0xea, 0xb5, - 0xb6, 0xd4, 0x69, 0x9e, 0x3e, 0x2d, 0xde, 0xcf, 0xce, 0x69, 0x71, 0x87, 0x25, 0x03, 0x38, 0x0c, - 0xe9, 0x3b, 0x3a, 0x8b, 0xd3, 0x64, 0x75, 0x9e, 0xec, 0xfb, 0xe2, 0x64, 0xb8, 0x2d, 0xc5, 0x3c, - 0x49, 0x10, 0xb4, 0xf9, 0x2a, 0x58, 0xb8, 0x33, 0x27, 0xa6, 0x69, 0xb6, 0x03, 0x9e, 0xed, 0x59, - 0x71, 0x36, 0x73, 0x47, 0x8d, 0x0f, 0x78, 0x56, 0xec, 0x9c, 0x2e, 0xdc, 0x35, 0x0d, 0xd3, 0x8c, - 0x72, 0x59, 0xb1, 0x66, 0x4e, 0x8b, 0x3b, 0x2c, 0x79, 0x01, 0xb2, 0x33, 0x9f, 0xdb, 0x94, 0x86, - 0x7a, 0x83, 0xa7, 0x79, 0x52, 0x9c, 0xa6, 0x27, 0x44, 0x98, 0xaa, 0xc9, 0x4f, 0x00, 0x21, 0x5d, - 0xfa, 0x6b, 0xca, 0x59, 0x85, 0xb3, 0xed, 0x7d, 0x57, 0x94, 0xea, 0x70, 0x8b, 0x61, 0x5b, 0x87, - 0x74, 0xb6, 0x46, 0xbb, 0xaf, 0x43, 0xd9, 0xd6, 0x28, 0x44, 0x98, 0xaa, 0x19, 0x18, 0x51, 0x6f, - 0xce, 0xc0, 0x66, 0x19, 0x38, 0x12, 0x22, 0x4c, 0xd5, 0x0c, 0x9c, 0x87, 0x7e, 0xc0, 0x40, 0xb5, - 0x0c, 0x34, 0x85, 0x08, 0x53, 0x35, 0x6b, 0xe3, 0x77, 0xbe, 0xeb, 0xe9, 0x87, 0x9c, 0xda, 0xd3, - 0xc6, 0x97, 0xbe, 0xeb, 0x21, 0xd7, 0x91, 0xe7, 0x50, 0x5f, 0x50, 0x67, 0x4d, 0xf5, 0x16, 0x07, - 0xbe, 0x2d, 0x06, 0x86, 0x4c, 0x82, 0x42, 0xc9, 0x90, 0x37, 0xa1, 0xf3, 0x6b, 0xac, 0x1f, 0x95, - 0x21, 0xe7, 0x4c, 0x82, 0x42, 0xc9, 0x90, 0x20, 0x5c, 0x79, 0x54, 0xd7, 0xca, 0x10, 0x9b, 0x49, - 0x50, 0x28, 0x8d, 0x33, 0x68, 0xe5, 0xbb, 0x9f, 0x39, 0x6b, 0x29, 0x1e, 0x07, 0x26, 0xb7, 0xa9, - 0x8a, 0x9b, 0x05, 0xe6, 0xc7, 0xd8, 0x0f, 0xdc, 0x59, 0xa4, 0x57, 0xda, 0xd5, 0x8e, 0x82, 0x49, - 0x64, 0xb8, 0x70, 0x98, 0x6b, 0xfc, 0x8f, 0xa4, 0x39, 0x01, 0x35, 0xa4, 0x33, 0xea, 0xae, 0xe9, - 0xfc, 0x2c, 0xf4, 0x97, 0x89, 0xb9, 0x73, 0x6b, 0x6c, 0xab, 0x90, 0x3a, 0x91, 0xef, 0x71, 0x7f, - 0x2b, 0x98, 0x44, 0xc6, 0x18, 0xb4, 0x5d, 0x57, 0xfc, 0xf7, 0xdd, 0x8c, 0x2e, 0xb4, 0xf2, 0xce, - 0x28, 0xcf, 0x69, 0xbc, 0x00, 0x39, 0xb1, 0xc0, 0xd6, 0x8c, 0x92, 0x72, 0x33, 0xea, 0x6b, 0xf6, - 0x39, 0xfc, 0xd8, 0xe7, 0xfb, 0x29, 0x28, 0x02, 0xe3, 0x29, 0xc0, 0xa6, 0xff, 0xf7, 0xb1, 0xc6, - 0x2f, 0x20, 0x27, 0x6d, 0xfe, 0xe0, 0xf4, 0x52, 0xc1, 0x5d, 0x3d, 0x87, 0xda, 0x92, 0xc6, 0x0e, - 0xdf, 0x69, 0xbf, 0x6f, 0xec, 0xfe, 0x15, 0x8d, 0x1d, 0xe4, 0x52, 0x63, 0x0c, 0x72, 0xe2, 0x07, - 0x76, 0x08, 0xe6, 0x88, 0xb1, 0x9f, 0x1e, 0x42, 0x44, 0x9f, 0x99, 0x35, 0x31, 0xcb, 0xff, 0x99, - 0xf5, 0x31, 0xd4, 0x98, 0x99, 0xd8, 0x8d, 0xf2, 0x7e, 0xe3, 0x19, 0x15, 0x14, 0x81, 0xf1, 0x04, - 0xea, 0xdc, 0x39, 0x9b, 0xd7, 0x95, 0xed, 0xd7, 0x3f, 0x40, 0x9d, 0xbb, 0xa4, 0xec, 0x3b, 0x15, - 0x63, 0xdc, 0x29, 0xff, 0x12, 0xfb, 0x20, 0x81, 0x9c, 0x1c, 0x9e, 0xbc, 0x82, 0x46, 0xd2, 0x30, - 0x91, 0x2e, 0xb5, 0xab, 0x9d, 0xe6, 0xe9, 0x77, 0xc5, 0xd5, 0x26, 0x2d, 0xc7, 0x2b, 0xce, 0x10, - 0xd2, 0x03, 0x35, 0x5a, 0x4d, 0xa3, 0x59, 0xe8, 0x06, 0xb1, 0xeb, 0x7b, 0xdc, 0x71, 0xfb, 0x67, - 0xdb, 0x6a, 0xca, 0xf1, 0x1c, 0x42, 0x7e, 0x04, 0x79, 0xe6, 0x7b, 0x71, 0xe8, 0x2f, 0xb8, 0x89, - 0xf6, 0x1e, 0xa0, 0x2f, 0x44, 0x3c, 0x43, 0x4a, 0x18, 0x7d, 0x68, 0x6e, 0x1d, 0xec, 0x33, 0x07, - 0xc3, 0x2b, 0x90, 0x93, 0xa3, 0xb1, 0x04, 0xc9, 0xe1, 0xa6, 0xe2, 0x07, 0xa0, 0x81, 0x9b, 0x85, - 0x3d, 0xd7, 0xf9, 0x7b, 0x05, 0x9a, 0x5b, 0x87, 0x23, 0x2f, 0xa1, 0xee, 0xbe, 0x65, 0x83, 0x54, - 0xdc, 0xe7, 0xb3, 0xd2, 0x72, 0x06, 0x17, 0xce, 0x5a, 0x5c, 0xaa, 0x80, 0x38, 0xfd, 0x9b, 0xe3, - 0xc5, 0xc9, 0x55, 0x7e, 0x84, 0xfe, 0xd9, 0xf1, 0xe2, 0x84, 0x66, 0x10, 0xa3, 0xc5, 0x44, 0xae, - 0x7e, 0x02, 0xcd, 0x5b, 0x4e, 0xd0, 0x62, 0x38, 0xbf, 0x4c, 0x87, 0x73, 0xed, 0x13, 0x68, 0xde, - 0x79, 0x82, 0x16, 0x73, 0xfa, 0x02, 0xb4, 0xdd, 0xa2, 0x8a, 0xdd, 0x40, 0x8e, 0x01, 0xb2, 0xaf, - 0x22, 0x3e, 0x86, 0x8a, 0x5b, 0x2b, 0xc6, 0xe9, 0x26, 0x53, 0x5a, 0xe0, 0x0e, 0x23, 0x3d, 0x60, - 0x3a, 0x19, 0x93, 0x95, 0xb5, 0xc7, 0x8b, 0x1b, 0x65, 0x56, 0x42, 0xb1, 0xf2, 0xe4, 0x0f, 0x09, - 0x6a, 0xec, 0x47, 0x8f, 0x7c, 0x05, 0x47, 0xf6, 0xed, 0xeb, 0xe1, 0x60, 0x74, 0x71, 0x77, 0x65, - 0x8d, 0x46, 0xbd, 0x73, 0x4b, 0xfb, 0x82, 0x10, 0x68, 0xa1, 0x75, 0x69, 0xf5, 0xc7, 0xd9, 0x9a, - 0x44, 0x1e, 0xc1, 0x97, 0xe6, 0xad, 0x3d, 0x1c, 0xf4, 0x7b, 0x63, 0x2b, 0x5b, 0xae, 0x30, 0xde, - 0xb4, 0x86, 0x83, 0x89, 0x85, 0xd9, 0x62, 0x95, 0xa8, 0xd0, 0xe8, 0x99, 0xe6, 0x9d, 0x6d, 0x59, - 0xa8, 0xd5, 0xc8, 0x11, 0x34, 0xd1, 0xba, 0xba, 0x99, 0x58, 0x62, 0xa1, 0xce, 0x5e, 0xa3, 0xd5, - 0x9f, 0xdc, 0xa1, 0xdd, 0xd7, 0x0e, 0x58, 0x34, 0xb2, 0xae, 0x4d, 0x1e, 0xc9, 0x2c, 0x32, 0xf1, - 0xc6, 0xe6, 0x51, 0x83, 0x34, 0xa0, 0x76, 0x79, 0x33, 0xb8, 0xd6, 0x14, 0xa2, 0x40, 0x7d, 0x68, - 0xf5, 0x26, 0x96, 0x06, 0xec, 0xf1, 0x1c, 0x7b, 0x67, 0x63, 0xad, 0xc9, 0x1e, 0x6d, 0xbc, 0xbd, - 0xb6, 0x34, 0xf5, 0xb5, 0xfa, 0xe1, 0xfe, 0x58, 0xfa, 0xf3, 0xfe, 0x58, 0xfa, 0xeb, 0xfe, 0x58, - 0xfa, 0x27, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x5e, 0x59, 0x8a, 0x11, 0x0b, 0x00, 0x00, +var fileDescriptor_trace_a154d83c271edb68 = []byte{ + // 1006 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xdd, 0x6e, 0xe3, 0x44, + 0x14, 0xc7, 0x71, 0x3e, 0x36, 0xc9, 0x49, 0x9a, 0x9a, 0x81, 0x22, 0x63, 0x76, 0xab, 0x10, 0x56, + 0xab, 0x48, 0x48, 0x41, 0x5b, 0x09, 0xed, 0x05, 0xbb, 0x88, 0x34, 0x76, 0xdb, 0x54, 0x69, 0x6b, + 0x9d, 0xa4, 0xe5, 0xb2, 0x38, 0xc9, 0xb0, 0xf5, 0x2a, 0xb1, 0x2d, 0x7b, 0x12, 0xb4, 0x0f, 0xc0, + 0xbb, 0xed, 0x1d, 0x3c, 0x02, 0xea, 0x15, 0x8f, 0x81, 0x66, 0xc6, 0x8e, 0xe3, 0xd4, 0xf1, 0x2e, + 0x0b, 0x77, 0x73, 0xc6, 0xff, 0xdf, 0x99, 0xaf, 0xf3, 0x3f, 0x32, 0xd4, 0x59, 0x60, 0x4f, 0x69, + 0xd7, 0x0f, 0x3c, 0xe6, 0x91, 0x9a, 0xbf, 0x9c, 0x84, 0xcb, 0x49, 0xd7, 0x9f, 0xb4, 0xff, 0x3e, + 0x00, 0x18, 0xf3, 0x4f, 0xe6, 0x8a, 0xba, 0x8c, 0x74, 0xa1, 0xc4, 0xde, 0xfa, 0x54, 0x53, 0x5a, + 0x4a, 0xa7, 0x79, 0xa4, 0x77, 0xd7, 0xc2, 0x6e, 0x22, 0xea, 0x8e, 0xdf, 0xfa, 0x14, 0x85, 0x8e, + 0x7c, 0x01, 0x8f, 0x7c, 0x4a, 0x83, 0x81, 0xa1, 0x15, 0x5a, 0x4a, 0xa7, 0x81, 0x51, 0x44, 0x1e, + 0x43, 0x8d, 0x39, 0x0b, 0x1a, 0x32, 0x7b, 0xe1, 0x6b, 0xc5, 0x96, 0xd2, 0x29, 0x62, 0x32, 0x41, + 0x86, 0xd0, 0xf4, 0x97, 0x93, 0xb9, 0x13, 0xde, 0x5d, 0xd0, 0x30, 0xb4, 0x5f, 0x53, 0xad, 0xd4, + 0x52, 0x3a, 0xf5, 0xa3, 0xa7, 0xd9, 0xeb, 0x59, 0x29, 0x2d, 0x6e, 0xb1, 0x64, 0x00, 0x7b, 0x01, + 0x7d, 0x43, 0xa7, 0x2c, 0x4e, 0x56, 0x16, 0xc9, 0xbe, 0xc9, 0x4e, 0x86, 0x9b, 0x52, 0x4c, 0x93, + 0x04, 0x41, 0x9d, 0x2d, 0xfd, 0xb9, 0x33, 0xb5, 0x19, 0x8d, 0xb3, 0x3d, 0x12, 0xd9, 0x9e, 0x65, + 0x67, 0x33, 0xb6, 0xd4, 0xf8, 0x80, 0xe7, 0x87, 0x9d, 0xd1, 0xb9, 0xb3, 0xa2, 0x41, 0x9c, 0xb1, + 0x92, 0x77, 0x58, 0x23, 0xa5, 0xc5, 0x2d, 0x96, 0xbc, 0x80, 0x8a, 0x3d, 0x9b, 0x59, 0x94, 0x06, + 0x5a, 0x55, 0xa4, 0x79, 0x92, 0x9d, 0xa6, 0x27, 0x45, 0x18, 0xab, 0xc9, 0x4f, 0x00, 0x01, 0x5d, + 0x78, 0x2b, 0x2a, 0xd8, 0x9a, 0x60, 0x5b, 0xbb, 0xae, 0x28, 0xd6, 0xe1, 0x06, 0xc3, 0x97, 0x0e, + 0xe8, 0x74, 0x85, 0x56, 0x5f, 0x83, 0xbc, 0xa5, 0x51, 0x8a, 0x30, 0x56, 0x73, 0x30, 0xa4, 0xee, + 0x8c, 0x83, 0xf5, 0x3c, 0x70, 0x24, 0x45, 0x18, 0xab, 0x39, 0x38, 0x0b, 0x3c, 0x9f, 0x83, 0x8d, + 0x3c, 0xd0, 0x90, 0x22, 0x8c, 0xd5, 0xbc, 0x8c, 0xdf, 0x78, 0x8e, 0xab, 0xed, 0x09, 0x6a, 0x47, + 0x19, 0x9f, 0x7b, 0x8e, 0x8b, 0x42, 0x47, 0x9e, 0x43, 0x79, 0x4e, 0xed, 0x15, 0xd5, 0x9a, 0x02, + 0xf8, 0x2a, 0x1b, 0x18, 0x72, 0x09, 0x4a, 0x25, 0x47, 0x5e, 0x07, 0xf6, 0xaf, 0x4c, 0xdb, 0xcf, + 0x43, 0x4e, 0xb9, 0x04, 0xa5, 0x92, 0x23, 0x7e, 0xb0, 0x74, 0xa9, 0xa6, 0xe6, 0x21, 0x16, 0x97, + 0xa0, 0x54, 0xea, 0x27, 0xd0, 0x4c, 0x57, 0x3f, 0x77, 0xd6, 0x42, 0x0e, 0x07, 0x86, 0xb0, 0x69, + 0x03, 0x93, 0x09, 0xee, 0x47, 0xe6, 0xf9, 0xce, 0x34, 0xd4, 0x0a, 0xad, 0x62, 0xa7, 0x86, 0x51, + 0xa4, 0x3b, 0xb0, 0x97, 0x2a, 0xfc, 0xf7, 0xa4, 0x69, 0x43, 0x23, 0xa0, 0x53, 0xea, 0xac, 0xe8, + 0xec, 0x24, 0xf0, 0x16, 0x91, 0xb9, 0x53, 0x73, 0x7c, 0xa9, 0x80, 0xda, 0xa1, 0xe7, 0x0a, 0x7f, + 0xd7, 0x30, 0x8a, 0xf4, 0x31, 0xa8, 0xdb, 0xae, 0xf8, 0xef, 0xab, 0xe9, 0x5d, 0x68, 0xa6, 0x9d, + 0x91, 0x9f, 0x53, 0x7f, 0x01, 0x95, 0xc8, 0x02, 0x1b, 0x3d, 0x4a, 0x49, 0xf5, 0xa8, 0xcf, 0xf9, + 0x73, 0x78, 0xcc, 0x13, 0xeb, 0xd5, 0x50, 0x06, 0xfa, 0x53, 0x80, 0xa4, 0xfe, 0x77, 0xb1, 0xfa, + 0x2f, 0x50, 0x89, 0xca, 0xfc, 0xc1, 0xee, 0x95, 0x8c, 0xbb, 0x7a, 0x0e, 0xa5, 0x05, 0x65, 0xb6, + 0x58, 0x69, 0xb7, 0x6f, 0xac, 0xfe, 0x05, 0x65, 0x36, 0x0a, 0xa9, 0x3e, 0x86, 0x4a, 0xe4, 0x07, + 0xbe, 0x09, 0xee, 0x88, 0xb1, 0x17, 0x6f, 0x42, 0x46, 0x1f, 0x99, 0x35, 0x32, 0xcb, 0xff, 0x99, + 0xf5, 0x31, 0x94, 0xb8, 0x99, 0xf8, 0x8d, 0x8a, 0x7a, 0x13, 0x19, 0x6b, 0x28, 0x03, 0xfd, 0x09, + 0x94, 0x85, 0x73, 0x92, 0xcf, 0x85, 0xcd, 0xcf, 0xdf, 0x43, 0x59, 0xb8, 0x24, 0xef, 0x9d, 0xb2, + 0x31, 0xe1, 0x94, 0x7f, 0x89, 0xbd, 0x53, 0xa0, 0x12, 0x6d, 0x9e, 0xbc, 0x82, 0x6a, 0x54, 0x30, + 0xa1, 0xa6, 0xb4, 0x8a, 0x9d, 0xfa, 0xd1, 0xd7, 0xd9, 0xa7, 0x8d, 0x4a, 0x4e, 0x9c, 0x78, 0x8d, + 0x90, 0x1e, 0x34, 0xc2, 0xe5, 0x24, 0x9c, 0x06, 0x8e, 0xcf, 0x1c, 0xcf, 0x15, 0x8e, 0xdb, 0xdd, + 0xdb, 0x96, 0x13, 0x81, 0xa7, 0x10, 0xf2, 0x03, 0x54, 0xa6, 0x9e, 0xcb, 0x02, 0x6f, 0x2e, 0x4c, + 0xb4, 0x73, 0x03, 0x7d, 0x29, 0x12, 0x19, 0x62, 0x42, 0xef, 0x43, 0x7d, 0x63, 0x63, 0x1f, 0xd9, + 0x18, 0x5e, 0x41, 0x25, 0xda, 0x1a, 0x4f, 0x10, 0x6d, 0x6e, 0x22, 0x7f, 0x00, 0xaa, 0x98, 0x4c, + 0xec, 0xb8, 0xce, 0xdf, 0x0b, 0x50, 0xdf, 0xd8, 0x1c, 0x79, 0x09, 0x65, 0xe7, 0x8e, 0x37, 0x52, + 0x79, 0x9f, 0xcf, 0x72, 0x8f, 0x33, 0x38, 0xb3, 0x57, 0xf2, 0x52, 0x25, 0x24, 0xe8, 0xdf, 0x6c, + 0x97, 0x45, 0x57, 0xf9, 0x1e, 0xfa, 0x67, 0xdb, 0x65, 0x11, 0xcd, 0x21, 0x4e, 0xcb, 0x8e, 0x5c, + 0xfc, 0x00, 0x5a, 0x94, 0x9c, 0xa4, 0x65, 0x73, 0x7e, 0x19, 0x37, 0xe7, 0xd2, 0x07, 0xd0, 0xa2, + 0xf2, 0x24, 0x2d, 0xfb, 0xf4, 0x19, 0xa8, 0xdb, 0x87, 0xca, 0x76, 0x03, 0x39, 0x04, 0x58, 0xbf, + 0x8a, 0x7c, 0x8c, 0x06, 0x6e, 0xcc, 0xe8, 0x47, 0x49, 0xa6, 0xf8, 0x80, 0x5b, 0x8c, 0xf2, 0x80, + 0xe9, 0xac, 0x99, 0xf5, 0xb1, 0x76, 0x78, 0x31, 0x51, 0xae, 0x8f, 0x90, 0xad, 0x6c, 0xff, 0xa1, + 0x40, 0x89, 0xff, 0xe8, 0x91, 0xcf, 0x60, 0xdf, 0xba, 0x3e, 0x1e, 0x0e, 0x46, 0x67, 0xb7, 0x17, + 0xe6, 0x68, 0xd4, 0x3b, 0x35, 0xd5, 0x4f, 0x08, 0x81, 0x26, 0x9a, 0xe7, 0x66, 0x7f, 0xbc, 0x9e, + 0x53, 0xc8, 0x01, 0x7c, 0x6a, 0x5c, 0x5b, 0xc3, 0x41, 0xbf, 0x37, 0x36, 0xd7, 0xd3, 0x05, 0xce, + 0x1b, 0xe6, 0x70, 0x70, 0x63, 0xe2, 0x7a, 0xb2, 0x48, 0x1a, 0x50, 0xed, 0x19, 0xc6, 0xad, 0x65, + 0x9a, 0xa8, 0x96, 0xc8, 0x3e, 0xd4, 0xd1, 0xbc, 0xb8, 0xba, 0x31, 0xe5, 0x44, 0x99, 0x7f, 0x46, + 0xb3, 0x7f, 0x73, 0x8b, 0x56, 0x5f, 0x7d, 0xc4, 0xa3, 0x91, 0x79, 0x69, 0x88, 0xa8, 0xc2, 0x23, + 0x03, 0xaf, 0x2c, 0x11, 0x55, 0x49, 0x15, 0x4a, 0xe7, 0x57, 0x83, 0x4b, 0xb5, 0x46, 0x6a, 0x50, + 0x1e, 0x9a, 0xbd, 0x1b, 0x53, 0x05, 0x3e, 0x3c, 0xc5, 0xde, 0xc9, 0x58, 0xad, 0xf3, 0xa1, 0x85, + 0xd7, 0x97, 0xa6, 0xda, 0x68, 0xff, 0x08, 0xfb, 0xc9, 0x4b, 0x1e, 0xdb, 0x6c, 0x7a, 0x47, 0xbe, + 0x85, 0xf2, 0x84, 0x0f, 0xa2, 0x72, 0x3d, 0xc8, 0x7c, 0x74, 0x94, 0x9a, 0xf6, 0x77, 0xf0, 0x65, + 0xdf, 0x5b, 0xf8, 0x01, 0x0d, 0x43, 0x3a, 0xdb, 0xce, 0x44, 0xa0, 0x34, 0xb3, 0x99, 0x1d, 0x19, + 0x4f, 0x8c, 0x8f, 0x1b, 0xef, 0xee, 0x0f, 0x95, 0x3f, 0xef, 0x0f, 0x95, 0xbf, 0xee, 0x0f, 0x95, + 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x80, 0x70, 0x3c, 0x82, 0x0b, 0x00, 0x00, } diff --git a/pb/trace.proto b/pb/trace.proto index e6369ed..7599d33 100644 --- a/pb/trace.proto +++ b/pb/trace.proto @@ -139,3 +139,11 @@ message TraceEvent { optional string topic = 1; } } + +message TraceEventBatch { + repeated TraceEvent batch = 1; +} + +message CompressedTraceEventBatch { + optional bytes data = 1; +} diff --git a/tracer.go b/tracer.go index 01b1ec6..6e52c28 100644 --- a/tracer.go +++ b/tracer.go @@ -1,14 +1,24 @@ package pubsub import ( + "bytes" + "compress/gzip" + "context" "encoding/json" "io" "os" "sync" - - ggio "github.com/gogo/protobuf/io" + "time" pb "github.com/libp2p/go-libp2p-pubsub/pb" + + "github.com/libp2p/go-libp2p-core/helpers" + "github.com/libp2p/go-libp2p-core/host" + "github.com/libp2p/go-libp2p-core/network" + "github.com/libp2p/go-libp2p-core/peer" + "github.com/libp2p/go-libp2p-core/protocol" + + ggio "github.com/gogo/protobuf/io" ) type basicTracer struct { @@ -136,3 +146,152 @@ func (t *PBTracer) doWrite() { } var _ EventTracer = (*PBTracer)(nil) + +const RemoteTracerProtoID = protocol.ID("/libp2p/pubsub/tracer/1.0.0") + +// RemoteTracer is a tracer that sends trace events to a remote peer +type RemoteTracer struct { + basicTracer + ctx context.Context + host host.Host + pi peer.AddrInfo +} + +// NewRemoteTracer constructs a RemoteTracer, tracing to the peer identified by pi +func NewRemoteTracer(ctx context.Context, host host.Host, pi peer.AddrInfo) (*RemoteTracer, error) { + tr := &RemoteTracer{ctx: ctx, host: host, pi: pi, basicTracer: basicTracer{ch: make(chan struct{}, 1)}} + go tr.doWrite() + return tr, nil +} + +func (t *RemoteTracer) doWrite() { + var buf []*pb.TraceEvent + + s, err := t.openStream() + if err != nil { + log.Errorf("error opening remote tracer stream: %s", err.Error()) + return + } + + w := ggio.NewDelimitedWriter(s) + + for { + _, ok := <-t.ch + + // nil out the buffer to gc events + for i := range buf { + buf[i] = nil + } + + t.mx.Lock() + tmp := t.buf + t.buf = buf[:0] + buf = tmp + t.mx.Unlock() + + if len(buf) == 0 { + goto end + } + + { + batch := &pb.TraceEventBatch{Batch: buf} + blob, err := batch.Marshal() + if err != nil { + log.Errorf("error marshalling trace event batch: %s", err.Error()) + goto end + } + + // compress batch + var cbuf bytes.Buffer + gzipW := gzip.NewWriter(&cbuf) + _, err = gzipW.Write(blob) + if err != nil { + log.Errorf("error compressing trace event batch: %s", err.Error()) + goto end + } + err = gzipW.Close() + if err != nil { + log.Errorf("error compressing trace event batch: %s", err.Error()) + goto end + } + + cblob := cbuf.Bytes() + cbatch := &pb.CompressedTraceEventBatch{Data: cblob} + err = w.WriteMsg(cbatch) + if err != nil { + log.Errorf("error writing trace event data: %s", err.Error()) + if !ok { + goto end + } + + // reset output + s.Reset() + s, err = t.openStream() + if err != nil { + log.Errorf("error opening remote tracer stream: %s", err.Error()) + return + } + w = ggio.NewDelimitedWriter(s) + } + } + + end: + if !ok { + helpers.FullClose(s) + return + } + } +} + +func (t *RemoteTracer) connect() error { + for { + ctx, cancel := context.WithTimeout(t.ctx, time.Minute) + err := t.host.Connect(ctx, t.pi) + cancel() + if err != nil { + if t.ctx.Err() != nil { + return err + } + + // wait a minute and try again, to account for transient server downtime + select { + case <-time.After(time.Minute): + continue + case <-t.ctx.Done(): + return t.ctx.Err() + } + } + + return nil + } +} + +func (t *RemoteTracer) openStream() (network.Stream, error) { + for { + err := t.connect() + if err != nil { + return nil, err + } + + ctx, cancel := context.WithTimeout(t.ctx, time.Minute) + s, err := t.host.NewStream(ctx, t.pi.ID, RemoteTracerProtoID) + cancel() + if err != nil { + if t.ctx.Err() != nil { + return nil, err + } + + // wait a minute and try again, to account for transient server downtime + select { + case <-time.After(time.Minute): + continue + case <-t.ctx.Done(): + return nil, t.ctx.Err() + } + } + + return s, nil + } +} + +var _ EventTracer = (*RemoteTracer)(nil) From 2fc5518a003530845dc46584651569866a6165ef Mon Sep 17 00:00:00 2001 From: vyzo Date: Thu, 14 Nov 2019 13:05:18 +0200 Subject: [PATCH 16/25] remote tracer: wait a second to accumulate batches --- tracer.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tracer.go b/tracer.go index 6e52c28..dbef80a 100644 --- a/tracer.go +++ b/tracer.go @@ -178,11 +178,14 @@ func (t *RemoteTracer) doWrite() { for { _, ok := <-t.ch - // nil out the buffer to gc events + // nil out the buffer to gc events when swapping buffers for i := range buf { buf[i] = nil } + // wait a bit to accumulate a batch + time.Sleep(time.Second) + t.mx.Lock() tmp := t.buf t.buf = buf[:0] From db8e2195eaaafdf2abc17060225d7586c874ee1e Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 18 Nov 2019 17:12:42 +0200 Subject: [PATCH 17/25] remove CompressedTraceEventBatch from trace protobuf --- pb/trace.pb.go | 852 ++++++++++++++++++++++++++----------------------- pb/trace.proto | 4 - 2 files changed, 456 insertions(+), 400 deletions(-) diff --git a/pb/trace.pb.go b/pb/trace.pb.go index b9b829d..009d03d 100644 --- a/pb/trace.pb.go +++ b/pb/trace.pb.go @@ -3,11 +3,12 @@ package pubsub_pb -import proto "github.com/gogo/protobuf/proto" -import fmt "fmt" -import math "math" - -import io "io" +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -53,6 +54,7 @@ var TraceEvent_Type_name = map[int32]string{ 11: "GRAFT", 12: "PRUNE", } + var TraceEvent_Type_value = map[string]int32{ "PUBLISH_MESSAGE": 0, "REJECT_MESSAGE": 1, @@ -74,9 +76,11 @@ func (x TraceEvent_Type) Enum() *TraceEvent_Type { *p = x return p } + func (x TraceEvent_Type) String() string { return proto.EnumName(TraceEvent_Type_name, int32(x)) } + func (x *TraceEvent_Type) UnmarshalJSON(data []byte) error { value, err := proto.UnmarshalJSONEnum(TraceEvent_Type_value, data, "TraceEvent_Type") if err != nil { @@ -85,8 +89,9 @@ func (x *TraceEvent_Type) UnmarshalJSON(data []byte) error { *x = TraceEvent_Type(value) return nil } + func (TraceEvent_Type) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 0} + return fileDescriptor_0571941a1d628a80, []int{0, 0} } type TraceEvent struct { @@ -115,7 +120,7 @@ func (m *TraceEvent) Reset() { *m = TraceEvent{} } func (m *TraceEvent) String() string { return proto.CompactTextString(m) } func (*TraceEvent) ProtoMessage() {} func (*TraceEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0} + return fileDescriptor_0571941a1d628a80, []int{0} } func (m *TraceEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -132,8 +137,8 @@ func (m *TraceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (dst *TraceEvent) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent.Merge(dst, src) +func (m *TraceEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent.Merge(m, src) } func (m *TraceEvent) XXX_Size() int { return m.Size() @@ -268,7 +273,7 @@ func (m *TraceEvent_PublishMessage) Reset() { *m = TraceEvent_PublishMes func (m *TraceEvent_PublishMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_PublishMessage) ProtoMessage() {} func (*TraceEvent_PublishMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 0} + return fileDescriptor_0571941a1d628a80, []int{0, 0} } func (m *TraceEvent_PublishMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -285,8 +290,8 @@ func (m *TraceEvent_PublishMessage) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } -func (dst *TraceEvent_PublishMessage) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_PublishMessage.Merge(dst, src) +func (m *TraceEvent_PublishMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_PublishMessage.Merge(m, src) } func (m *TraceEvent_PublishMessage) XXX_Size() int { return m.Size() @@ -324,7 +329,7 @@ func (m *TraceEvent_RejectMessage) Reset() { *m = TraceEvent_RejectMessa func (m *TraceEvent_RejectMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RejectMessage) ProtoMessage() {} func (*TraceEvent_RejectMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 1} + return fileDescriptor_0571941a1d628a80, []int{0, 1} } func (m *TraceEvent_RejectMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -341,8 +346,8 @@ func (m *TraceEvent_RejectMessage) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } -func (dst *TraceEvent_RejectMessage) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_RejectMessage.Merge(dst, src) +func (m *TraceEvent_RejectMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_RejectMessage.Merge(m, src) } func (m *TraceEvent_RejectMessage) XXX_Size() int { return m.Size() @@ -386,7 +391,7 @@ func (m *TraceEvent_DuplicateMessage) Reset() { *m = TraceEvent_Duplicat func (m *TraceEvent_DuplicateMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DuplicateMessage) ProtoMessage() {} func (*TraceEvent_DuplicateMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 2} + return fileDescriptor_0571941a1d628a80, []int{0, 2} } func (m *TraceEvent_DuplicateMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -403,8 +408,8 @@ func (m *TraceEvent_DuplicateMessage) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (dst *TraceEvent_DuplicateMessage) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_DuplicateMessage.Merge(dst, src) +func (m *TraceEvent_DuplicateMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_DuplicateMessage.Merge(m, src) } func (m *TraceEvent_DuplicateMessage) XXX_Size() int { return m.Size() @@ -440,7 +445,7 @@ func (m *TraceEvent_DeliverMessage) Reset() { *m = TraceEvent_DeliverMes func (m *TraceEvent_DeliverMessage) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DeliverMessage) ProtoMessage() {} func (*TraceEvent_DeliverMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 3} + return fileDescriptor_0571941a1d628a80, []int{0, 3} } func (m *TraceEvent_DeliverMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -457,8 +462,8 @@ func (m *TraceEvent_DeliverMessage) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } -func (dst *TraceEvent_DeliverMessage) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_DeliverMessage.Merge(dst, src) +func (m *TraceEvent_DeliverMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_DeliverMessage.Merge(m, src) } func (m *TraceEvent_DeliverMessage) XXX_Size() int { return m.Size() @@ -488,7 +493,7 @@ func (m *TraceEvent_AddPeer) Reset() { *m = TraceEvent_AddPeer{} } func (m *TraceEvent_AddPeer) String() string { return proto.CompactTextString(m) } func (*TraceEvent_AddPeer) ProtoMessage() {} func (*TraceEvent_AddPeer) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 4} + return fileDescriptor_0571941a1d628a80, []int{0, 4} } func (m *TraceEvent_AddPeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -505,8 +510,8 @@ func (m *TraceEvent_AddPeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (dst *TraceEvent_AddPeer) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_AddPeer.Merge(dst, src) +func (m *TraceEvent_AddPeer) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_AddPeer.Merge(m, src) } func (m *TraceEvent_AddPeer) XXX_Size() int { return m.Size() @@ -542,7 +547,7 @@ func (m *TraceEvent_RemovePeer) Reset() { *m = TraceEvent_RemovePeer{} } func (m *TraceEvent_RemovePeer) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RemovePeer) ProtoMessage() {} func (*TraceEvent_RemovePeer) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 5} + return fileDescriptor_0571941a1d628a80, []int{0, 5} } func (m *TraceEvent_RemovePeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -559,8 +564,8 @@ func (m *TraceEvent_RemovePeer) XXX_Marshal(b []byte, deterministic bool) ([]byt return b[:n], nil } } -func (dst *TraceEvent_RemovePeer) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_RemovePeer.Merge(dst, src) +func (m *TraceEvent_RemovePeer) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_RemovePeer.Merge(m, src) } func (m *TraceEvent_RemovePeer) XXX_Size() int { return m.Size() @@ -590,7 +595,7 @@ func (m *TraceEvent_RecvRPC) Reset() { *m = TraceEvent_RecvRPC{} } func (m *TraceEvent_RecvRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RecvRPC) ProtoMessage() {} func (*TraceEvent_RecvRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 6} + return fileDescriptor_0571941a1d628a80, []int{0, 6} } func (m *TraceEvent_RecvRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -607,8 +612,8 @@ func (m *TraceEvent_RecvRPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (dst *TraceEvent_RecvRPC) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_RecvRPC.Merge(dst, src) +func (m *TraceEvent_RecvRPC) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_RecvRPC.Merge(m, src) } func (m *TraceEvent_RecvRPC) XXX_Size() int { return m.Size() @@ -645,7 +650,7 @@ func (m *TraceEvent_SendRPC) Reset() { *m = TraceEvent_SendRPC{} } func (m *TraceEvent_SendRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_SendRPC) ProtoMessage() {} func (*TraceEvent_SendRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 7} + return fileDescriptor_0571941a1d628a80, []int{0, 7} } func (m *TraceEvent_SendRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -662,8 +667,8 @@ func (m *TraceEvent_SendRPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (dst *TraceEvent_SendRPC) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_SendRPC.Merge(dst, src) +func (m *TraceEvent_SendRPC) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_SendRPC.Merge(m, src) } func (m *TraceEvent_SendRPC) XXX_Size() int { return m.Size() @@ -700,7 +705,7 @@ func (m *TraceEvent_DropRPC) Reset() { *m = TraceEvent_DropRPC{} } func (m *TraceEvent_DropRPC) String() string { return proto.CompactTextString(m) } func (*TraceEvent_DropRPC) ProtoMessage() {} func (*TraceEvent_DropRPC) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 8} + return fileDescriptor_0571941a1d628a80, []int{0, 8} } func (m *TraceEvent_DropRPC) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -717,8 +722,8 @@ func (m *TraceEvent_DropRPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (dst *TraceEvent_DropRPC) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_DropRPC.Merge(dst, src) +func (m *TraceEvent_DropRPC) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_DropRPC.Merge(m, src) } func (m *TraceEvent_DropRPC) XXX_Size() int { return m.Size() @@ -754,7 +759,7 @@ func (m *TraceEvent_Join) Reset() { *m = TraceEvent_Join{} } func (m *TraceEvent_Join) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Join) ProtoMessage() {} func (*TraceEvent_Join) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 9} + return fileDescriptor_0571941a1d628a80, []int{0, 9} } func (m *TraceEvent_Join) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -771,8 +776,8 @@ func (m *TraceEvent_Join) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } -func (dst *TraceEvent_Join) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_Join.Merge(dst, src) +func (m *TraceEvent_Join) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_Join.Merge(m, src) } func (m *TraceEvent_Join) XXX_Size() int { return m.Size() @@ -801,7 +806,7 @@ func (m *TraceEvent_Leave) Reset() { *m = TraceEvent_Leave{} } func (m *TraceEvent_Leave) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Leave) ProtoMessage() {} func (*TraceEvent_Leave) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 10} + return fileDescriptor_0571941a1d628a80, []int{0, 10} } func (m *TraceEvent_Leave) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -818,8 +823,8 @@ func (m *TraceEvent_Leave) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } -func (dst *TraceEvent_Leave) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_Leave.Merge(dst, src) +func (m *TraceEvent_Leave) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_Leave.Merge(m, src) } func (m *TraceEvent_Leave) XXX_Size() int { return m.Size() @@ -849,7 +854,7 @@ func (m *TraceEvent_Graft) Reset() { *m = TraceEvent_Graft{} } func (m *TraceEvent_Graft) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Graft) ProtoMessage() {} func (*TraceEvent_Graft) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 11} + return fileDescriptor_0571941a1d628a80, []int{0, 11} } func (m *TraceEvent_Graft) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -866,8 +871,8 @@ func (m *TraceEvent_Graft) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } -func (dst *TraceEvent_Graft) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_Graft.Merge(dst, src) +func (m *TraceEvent_Graft) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_Graft.Merge(m, src) } func (m *TraceEvent_Graft) XXX_Size() int { return m.Size() @@ -904,7 +909,7 @@ func (m *TraceEvent_Prune) Reset() { *m = TraceEvent_Prune{} } func (m *TraceEvent_Prune) String() string { return proto.CompactTextString(m) } func (*TraceEvent_Prune) ProtoMessage() {} func (*TraceEvent_Prune) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 12} + return fileDescriptor_0571941a1d628a80, []int{0, 12} } func (m *TraceEvent_Prune) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -921,8 +926,8 @@ func (m *TraceEvent_Prune) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } -func (dst *TraceEvent_Prune) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_Prune.Merge(dst, src) +func (m *TraceEvent_Prune) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_Prune.Merge(m, src) } func (m *TraceEvent_Prune) XXX_Size() int { return m.Size() @@ -960,7 +965,7 @@ func (m *TraceEvent_RPCMeta) Reset() { *m = TraceEvent_RPCMeta{} } func (m *TraceEvent_RPCMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_RPCMeta) ProtoMessage() {} func (*TraceEvent_RPCMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 13} + return fileDescriptor_0571941a1d628a80, []int{0, 13} } func (m *TraceEvent_RPCMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -977,8 +982,8 @@ func (m *TraceEvent_RPCMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (dst *TraceEvent_RPCMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_RPCMeta.Merge(dst, src) +func (m *TraceEvent_RPCMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_RPCMeta.Merge(m, src) } func (m *TraceEvent_RPCMeta) XXX_Size() int { return m.Size() @@ -1022,7 +1027,7 @@ func (m *TraceEvent_MessageMeta) Reset() { *m = TraceEvent_MessageMeta{} func (m *TraceEvent_MessageMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_MessageMeta) ProtoMessage() {} func (*TraceEvent_MessageMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 14} + return fileDescriptor_0571941a1d628a80, []int{0, 14} } func (m *TraceEvent_MessageMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1039,8 +1044,8 @@ func (m *TraceEvent_MessageMeta) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } -func (dst *TraceEvent_MessageMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_MessageMeta.Merge(dst, src) +func (m *TraceEvent_MessageMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_MessageMeta.Merge(m, src) } func (m *TraceEvent_MessageMeta) XXX_Size() int { return m.Size() @@ -1077,7 +1082,7 @@ func (m *TraceEvent_SubMeta) Reset() { *m = TraceEvent_SubMeta{} } func (m *TraceEvent_SubMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_SubMeta) ProtoMessage() {} func (*TraceEvent_SubMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 15} + return fileDescriptor_0571941a1d628a80, []int{0, 15} } func (m *TraceEvent_SubMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1094,8 +1099,8 @@ func (m *TraceEvent_SubMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (dst *TraceEvent_SubMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_SubMeta.Merge(dst, src) +func (m *TraceEvent_SubMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_SubMeta.Merge(m, src) } func (m *TraceEvent_SubMeta) XXX_Size() int { return m.Size() @@ -1134,7 +1139,7 @@ func (m *TraceEvent_ControlMeta) Reset() { *m = TraceEvent_ControlMeta{} func (m *TraceEvent_ControlMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlMeta) ProtoMessage() {} func (*TraceEvent_ControlMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 16} + return fileDescriptor_0571941a1d628a80, []int{0, 16} } func (m *TraceEvent_ControlMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1151,8 +1156,8 @@ func (m *TraceEvent_ControlMeta) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } -func (dst *TraceEvent_ControlMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_ControlMeta.Merge(dst, src) +func (m *TraceEvent_ControlMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlMeta.Merge(m, src) } func (m *TraceEvent_ControlMeta) XXX_Size() int { return m.Size() @@ -1203,7 +1208,7 @@ func (m *TraceEvent_ControlIHaveMeta) Reset() { *m = TraceEvent_ControlI func (m *TraceEvent_ControlIHaveMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlIHaveMeta) ProtoMessage() {} func (*TraceEvent_ControlIHaveMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 17} + return fileDescriptor_0571941a1d628a80, []int{0, 17} } func (m *TraceEvent_ControlIHaveMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1220,8 +1225,8 @@ func (m *TraceEvent_ControlIHaveMeta) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (dst *TraceEvent_ControlIHaveMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_ControlIHaveMeta.Merge(dst, src) +func (m *TraceEvent_ControlIHaveMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlIHaveMeta.Merge(m, src) } func (m *TraceEvent_ControlIHaveMeta) XXX_Size() int { return m.Size() @@ -1257,7 +1262,7 @@ func (m *TraceEvent_ControlIWantMeta) Reset() { *m = TraceEvent_ControlI func (m *TraceEvent_ControlIWantMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlIWantMeta) ProtoMessage() {} func (*TraceEvent_ControlIWantMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 18} + return fileDescriptor_0571941a1d628a80, []int{0, 18} } func (m *TraceEvent_ControlIWantMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1274,8 +1279,8 @@ func (m *TraceEvent_ControlIWantMeta) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (dst *TraceEvent_ControlIWantMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_ControlIWantMeta.Merge(dst, src) +func (m *TraceEvent_ControlIWantMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlIWantMeta.Merge(m, src) } func (m *TraceEvent_ControlIWantMeta) XXX_Size() int { return m.Size() @@ -1304,7 +1309,7 @@ func (m *TraceEvent_ControlGraftMeta) Reset() { *m = TraceEvent_ControlG func (m *TraceEvent_ControlGraftMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlGraftMeta) ProtoMessage() {} func (*TraceEvent_ControlGraftMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 19} + return fileDescriptor_0571941a1d628a80, []int{0, 19} } func (m *TraceEvent_ControlGraftMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1321,8 +1326,8 @@ func (m *TraceEvent_ControlGraftMeta) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (dst *TraceEvent_ControlGraftMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_ControlGraftMeta.Merge(dst, src) +func (m *TraceEvent_ControlGraftMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlGraftMeta.Merge(m, src) } func (m *TraceEvent_ControlGraftMeta) XXX_Size() int { return m.Size() @@ -1351,7 +1356,7 @@ func (m *TraceEvent_ControlPruneMeta) Reset() { *m = TraceEvent_ControlP func (m *TraceEvent_ControlPruneMeta) String() string { return proto.CompactTextString(m) } func (*TraceEvent_ControlPruneMeta) ProtoMessage() {} func (*TraceEvent_ControlPruneMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{0, 20} + return fileDescriptor_0571941a1d628a80, []int{0, 20} } func (m *TraceEvent_ControlPruneMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1368,8 +1373,8 @@ func (m *TraceEvent_ControlPruneMeta) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (dst *TraceEvent_ControlPruneMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEvent_ControlPruneMeta.Merge(dst, src) +func (m *TraceEvent_ControlPruneMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEvent_ControlPruneMeta.Merge(m, src) } func (m *TraceEvent_ControlPruneMeta) XXX_Size() int { return m.Size() @@ -1398,7 +1403,7 @@ func (m *TraceEventBatch) Reset() { *m = TraceEventBatch{} } func (m *TraceEventBatch) String() string { return proto.CompactTextString(m) } func (*TraceEventBatch) ProtoMessage() {} func (*TraceEventBatch) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{1} + return fileDescriptor_0571941a1d628a80, []int{1} } func (m *TraceEventBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1415,8 +1420,8 @@ func (m *TraceEventBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } -func (dst *TraceEventBatch) XXX_Merge(src proto.Message) { - xxx_messageInfo_TraceEventBatch.Merge(dst, src) +func (m *TraceEventBatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceEventBatch.Merge(m, src) } func (m *TraceEventBatch) XXX_Size() int { return m.Size() @@ -1434,54 +1439,8 @@ func (m *TraceEventBatch) GetBatch() []*TraceEvent { return nil } -type CompressedTraceEventBatch struct { - Data []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *CompressedTraceEventBatch) Reset() { *m = CompressedTraceEventBatch{} } -func (m *CompressedTraceEventBatch) String() string { return proto.CompactTextString(m) } -func (*CompressedTraceEventBatch) ProtoMessage() {} -func (*CompressedTraceEventBatch) Descriptor() ([]byte, []int) { - return fileDescriptor_trace_a154d83c271edb68, []int{2} -} -func (m *CompressedTraceEventBatch) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *CompressedTraceEventBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_CompressedTraceEventBatch.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalTo(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (dst *CompressedTraceEventBatch) XXX_Merge(src proto.Message) { - xxx_messageInfo_CompressedTraceEventBatch.Merge(dst, src) -} -func (m *CompressedTraceEventBatch) XXX_Size() int { - return m.Size() -} -func (m *CompressedTraceEventBatch) XXX_DiscardUnknown() { - xxx_messageInfo_CompressedTraceEventBatch.DiscardUnknown(m) -} - -var xxx_messageInfo_CompressedTraceEventBatch proto.InternalMessageInfo - -func (m *CompressedTraceEventBatch) GetData() []byte { - if m != nil { - return m.Data - } - return nil -} - func init() { + proto.RegisterEnum("pubsub.pb.TraceEvent_Type", TraceEvent_Type_name, TraceEvent_Type_value) proto.RegisterType((*TraceEvent)(nil), "pubsub.pb.TraceEvent") proto.RegisterType((*TraceEvent_PublishMessage)(nil), "pubsub.pb.TraceEvent.PublishMessage") proto.RegisterType((*TraceEvent_RejectMessage)(nil), "pubsub.pb.TraceEvent.RejectMessage") @@ -1505,9 +1464,70 @@ func init() { proto.RegisterType((*TraceEvent_ControlGraftMeta)(nil), "pubsub.pb.TraceEvent.ControlGraftMeta") proto.RegisterType((*TraceEvent_ControlPruneMeta)(nil), "pubsub.pb.TraceEvent.ControlPruneMeta") proto.RegisterType((*TraceEventBatch)(nil), "pubsub.pb.TraceEventBatch") - proto.RegisterType((*CompressedTraceEventBatch)(nil), "pubsub.pb.CompressedTraceEventBatch") - proto.RegisterEnum("pubsub.pb.TraceEvent_Type", TraceEvent_Type_name, TraceEvent_Type_value) } + +func init() { proto.RegisterFile("trace.proto", fileDescriptor_0571941a1d628a80) } + +var fileDescriptor_0571941a1d628a80 = []byte{ + // 889 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xd1, 0x6e, 0xe2, 0x46, + 0x14, 0x86, 0xeb, 0x80, 0x63, 0x7c, 0x30, 0x8e, 0x99, 0x36, 0x95, 0xe5, 0xb6, 0x11, 0x9b, 0x5d, + 0x45, 0xa8, 0x2b, 0xa1, 0x2a, 0xdb, 0x55, 0xa5, 0xb6, 0x17, 0x25, 0x78, 0x92, 0x10, 0x91, 0xc4, + 0x32, 0x24, 0xbd, 0x8c, 0x8c, 0x99, 0x6e, 0xbc, 0x02, 0xdb, 0xb2, 0x07, 0xaa, 0x7d, 0xa2, 0xbe, + 0x4a, 0xef, 0xda, 0x47, 0xa8, 0x72, 0xb7, 0x6f, 0x51, 0xcd, 0x0c, 0x36, 0xc1, 0x31, 0x6c, 0xd4, + 0xde, 0xcd, 0x0c, 0xdf, 0x7f, 0xce, 0xe1, 0xcc, 0x7f, 0xc6, 0x50, 0xa7, 0x89, 0xe7, 0x93, 0x4e, + 0x9c, 0x44, 0x34, 0x42, 0x6a, 0x3c, 0x1f, 0xa7, 0xf3, 0x71, 0x27, 0x1e, 0x1f, 0x7e, 0x6c, 0x02, + 0x8c, 0xd8, 0x4f, 0x78, 0x41, 0x42, 0x8a, 0xda, 0x50, 0xa5, 0x1f, 0x62, 0x62, 0x4a, 0x2d, 0xa9, + 0xad, 0x1f, 0x5b, 0x9d, 0x1c, 0xec, 0xac, 0xa0, 0xce, 0xe8, 0x43, 0x4c, 0x90, 0x0e, 0xbb, 0x31, + 0x21, 0x49, 0xdf, 0x36, 0x77, 0x5a, 0x52, 0x5b, 0x43, 0x4d, 0x50, 0x69, 0x30, 0x23, 0x29, 0xf5, + 0x66, 0xb1, 0x59, 0x69, 0x49, 0xed, 0x0a, 0xfa, 0x19, 0xf4, 0x78, 0x3e, 0x9e, 0x06, 0xe9, 0xfd, + 0x25, 0x49, 0x53, 0xef, 0x1d, 0x31, 0xab, 0x2d, 0xa9, 0x5d, 0x3f, 0x7e, 0x55, 0x1e, 0xd6, 0x59, + 0x63, 0xd1, 0x8f, 0xd0, 0x48, 0xc8, 0x7b, 0xe2, 0xd3, 0x4c, 0x2c, 0x73, 0xf1, 0xcb, 0x72, 0xb1, + 0xfb, 0x18, 0x45, 0xbf, 0x80, 0x31, 0x99, 0xc7, 0xd3, 0xc0, 0xf7, 0x28, 0xc9, 0xe4, 0xbb, 0x5c, + 0x7e, 0x54, 0x2e, 0xb7, 0x0b, 0x34, 0xab, 0x7d, 0x42, 0xa6, 0xc1, 0x82, 0x24, 0x99, 0x5e, 0xd9, + 0x56, 0xbb, 0xbd, 0xc6, 0xa2, 0x0e, 0x28, 0xde, 0x64, 0xe2, 0x10, 0x92, 0x98, 0x35, 0x2e, 0xfb, + 0xa6, 0x5c, 0xd6, 0x15, 0x10, 0xfa, 0x1e, 0x20, 0x21, 0xb3, 0x68, 0x41, 0xb8, 0x44, 0xe5, 0x92, + 0xd6, 0xa6, 0x3f, 0x9a, 0x71, 0x2c, 0x4b, 0x42, 0xfc, 0x85, 0xeb, 0xf4, 0x4c, 0xd8, 0x96, 0xc5, + 0x15, 0x10, 0xe3, 0x53, 0x12, 0x4e, 0x18, 0x5f, 0xdf, 0xc6, 0x0f, 0x05, 0xc4, 0xf8, 0x49, 0x12, + 0xc5, 0x8c, 0xd7, 0xb6, 0xf1, 0xb6, 0x80, 0x98, 0x79, 0xde, 0x47, 0x41, 0x68, 0x36, 0x38, 0xbc, + 0xc1, 0x3c, 0x17, 0x51, 0x10, 0xa2, 0x6f, 0x41, 0x9e, 0x12, 0x6f, 0x41, 0x4c, 0x9d, 0xa3, 0x5f, + 0x95, 0xa3, 0x03, 0x86, 0x30, 0xf6, 0x5d, 0xe2, 0xfd, 0x46, 0xcd, 0xbd, 0x6d, 0xec, 0x19, 0x43, + 0x18, 0x1b, 0x27, 0xf3, 0x90, 0x98, 0xc6, 0x36, 0xd6, 0x61, 0x88, 0xf5, 0x06, 0xf4, 0x82, 0xe3, + 0x9a, 0xa0, 0xce, 0xc4, 0xb2, 0x6f, 0xf3, 0x09, 0xd0, 0x98, 0xcb, 0x69, 0x14, 0x07, 0x7e, 0x6a, + 0xee, 0xb4, 0x2a, 0x6d, 0xd5, 0x3a, 0x87, 0xc6, 0xba, 0xd3, 0x4a, 0x34, 0x5f, 0x80, 0x96, 0x10, + 0x9f, 0x04, 0x0b, 0x32, 0x39, 0x4d, 0xa2, 0xd9, 0x72, 0x3e, 0x74, 0xd8, 0x4d, 0x88, 0x97, 0x46, + 0x21, 0x1f, 0x0e, 0xd5, 0xfa, 0x09, 0x8c, 0x27, 0xa6, 0x7b, 0x6e, 0x30, 0xeb, 0x25, 0xe8, 0x05, + 0xc7, 0x3d, 0x95, 0x5a, 0x6d, 0x50, 0x32, 0x7f, 0xad, 0x86, 0x55, 0x44, 0x6d, 0xb0, 0x3e, 0x45, + 0x34, 0xe2, 0xe1, 0x54, 0xeb, 0x6b, 0x80, 0x47, 0xb6, 0x2a, 0xc0, 0xd6, 0x00, 0x94, 0xcc, 0x41, + 0xc5, 0x6a, 0x44, 0xb4, 0xd7, 0x50, 0x9d, 0x11, 0xea, 0xf1, 0x60, 0x9b, 0x4d, 0xe8, 0xf4, 0x2e, + 0x09, 0xf5, 0xac, 0x53, 0x50, 0x32, 0x7f, 0xe9, 0xb0, 0xcb, 0xfc, 0x38, 0x8a, 0xfe, 0x63, 0x9c, + 0xcc, 0x77, 0xff, 0x2b, 0xce, 0x3e, 0x54, 0xb9, 0x25, 0x1b, 0x20, 0xf3, 0x9b, 0xe6, 0x31, 0x54, + 0xeb, 0x4b, 0x90, 0x85, 0xfd, 0xf2, 0x73, 0xd1, 0xaa, 0x23, 0x90, 0x85, 0xd5, 0x4a, 0x5a, 0x5a, + 0xe0, 0xb8, 0xcd, 0x3e, 0xc5, 0xfd, 0x21, 0x81, 0xb2, 0x2c, 0x05, 0xbd, 0x81, 0xda, 0xf2, 0x0e, + 0x53, 0x53, 0x6a, 0x55, 0xda, 0xf5, 0xe3, 0x17, 0xe5, 0xb5, 0x2f, 0x2f, 0x7d, 0x29, 0xd2, 0xd2, + 0xf9, 0x38, 0xf5, 0x93, 0x20, 0xa6, 0x41, 0x14, 0x72, 0x9f, 0x6e, 0x9e, 0xec, 0xf9, 0x98, 0x8b, + 0x8e, 0x41, 0xf1, 0xa3, 0x90, 0x26, 0xd1, 0x94, 0xbb, 0x71, 0x63, 0xa2, 0x9e, 0x80, 0x78, 0xa3, + 0xbe, 0x83, 0xfa, 0xe3, 0xbc, 0xcf, 0x18, 0x96, 0xd7, 0xa0, 0x64, 0x09, 0x9b, 0xa0, 0x2e, 0xab, + 0x1c, 0x8b, 0x8f, 0x4b, 0xad, 0xd8, 0x88, 0x8f, 0x12, 0xd4, 0x1f, 0xa5, 0x43, 0x6f, 0x41, 0x0e, + 0xee, 0xd9, 0x13, 0x21, 0x3a, 0x71, 0xb4, 0xb5, 0xc0, 0xfe, 0xb9, 0xb7, 0x20, 0xb9, 0xec, 0x77, + 0x2f, 0xa4, 0xcb, 0x3e, 0x7c, 0x42, 0xf6, 0xab, 0x17, 0xd2, 0x4c, 0x26, 0x1e, 0x99, 0xca, 0x33, + 0x64, 0xdc, 0x00, 0x99, 0x4c, 0xbc, 0x37, 0xd5, 0x67, 0xc8, 0xb8, 0x1f, 0x78, 0x2b, 0xdf, 0x82, + 0xf1, 0xa4, 0xf0, 0x75, 0xff, 0x21, 0x04, 0x90, 0xb7, 0x57, 0xf4, 0x53, 0xb3, 0x8e, 0x56, 0xb2, + 0xbc, 0xf0, 0x75, 0x4e, 0xe2, 0xdc, 0x8b, 0x9c, 0x5b, 0x55, 0x5a, 0xb0, 0xf7, 0x0a, 0xc9, 0xab, + 0x2a, 0x20, 0x87, 0x7f, 0x49, 0x50, 0xe5, 0x5f, 0xfa, 0xcf, 0x61, 0xcf, 0xb9, 0x39, 0x19, 0xf4, + 0x87, 0xe7, 0x77, 0x97, 0x78, 0x38, 0xec, 0x9e, 0x61, 0xe3, 0x33, 0x84, 0x40, 0x77, 0xf1, 0x05, + 0xee, 0x8d, 0xf2, 0x33, 0x09, 0xed, 0x43, 0xd3, 0xbe, 0x71, 0x06, 0xfd, 0x5e, 0x77, 0x84, 0xf3, + 0xe3, 0x1d, 0xa6, 0xb7, 0xf1, 0xa0, 0x7f, 0x8b, 0xdd, 0xfc, 0xb0, 0x82, 0x34, 0xa8, 0x75, 0x6d, + 0xfb, 0xce, 0xc1, 0xd8, 0x35, 0xaa, 0x68, 0x0f, 0xea, 0x2e, 0xbe, 0xbc, 0xbe, 0xc5, 0xe2, 0x40, + 0x66, 0x3f, 0xbb, 0xb8, 0x77, 0x7b, 0xe7, 0x3a, 0x3d, 0x63, 0x97, 0xed, 0x86, 0xf8, 0xca, 0xe6, + 0x3b, 0x85, 0xed, 0x6c, 0xf7, 0xda, 0xe1, 0xbb, 0x1a, 0xaa, 0x41, 0xf5, 0xe2, 0xba, 0x7f, 0x65, + 0xa8, 0x48, 0x05, 0x79, 0x80, 0xbb, 0xb7, 0xd8, 0x00, 0xb6, 0x3c, 0x73, 0xbb, 0xa7, 0x23, 0xa3, + 0xce, 0x96, 0x8e, 0x7b, 0x73, 0x85, 0x0d, 0xed, 0xf0, 0x07, 0xd8, 0x5b, 0xdd, 0xca, 0x89, 0x47, + 0xfd, 0x7b, 0xf4, 0x0a, 0xe4, 0x31, 0x5b, 0x2c, 0x5d, 0xb6, 0x5f, 0x7a, 0x81, 0x27, 0xda, 0x9f, + 0x0f, 0x07, 0xd2, 0xdf, 0x0f, 0x07, 0xd2, 0x3f, 0x0f, 0x07, 0xd2, 0xbf, 0x01, 0x00, 0x00, 0xff, + 0xff, 0xa3, 0xb7, 0xeb, 0x75, 0x4b, 0x09, 0x00, 0x00, +} + func (m *TraceEvent) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2463,33 +2483,6 @@ func (m *TraceEventBatch) MarshalTo(dAtA []byte) (int, error) { return i, nil } -func (m *CompressedTraceEventBatch) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *CompressedTraceEventBatch) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.Data != nil { - dAtA[i] = 0xa - i++ - i = encodeVarintTrace(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) - } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) - } - return i, nil -} - func encodeVarintTrace(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -3018,22 +3011,6 @@ func (m *TraceEventBatch) Size() (n int) { return n } -func (m *CompressedTraceEventBatch) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Data != nil { - l = len(m.Data) - n += 1 + l + sovTrace(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - func sovTrace(x uint64) (n int) { for { n++ @@ -3062,7 +3039,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -3090,7 +3067,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= (TraceEvent_Type(b) & 0x7F) << shift + v |= TraceEvent_Type(b&0x7F) << shift if b < 0x80 { break } @@ -3110,7 +3087,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3119,6 +3096,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3141,7 +3121,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= (int64(b) & 0x7F) << shift + v |= int64(b&0x7F) << shift if b < 0x80 { break } @@ -3161,7 +3141,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3170,6 +3150,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3194,7 +3177,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3203,6 +3186,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3227,7 +3213,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3236,6 +3222,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3260,7 +3249,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3269,6 +3258,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3293,7 +3285,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3302,6 +3294,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3326,7 +3321,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3335,6 +3330,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3359,7 +3357,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3368,6 +3366,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3392,7 +3393,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3401,6 +3402,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3425,7 +3429,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3434,6 +3438,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3458,7 +3465,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3467,6 +3474,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3491,7 +3501,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3500,6 +3510,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3524,7 +3537,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3533,6 +3546,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3557,7 +3573,7 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3566,6 +3582,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3585,6 +3604,9 @@ func (m *TraceEvent) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -3613,7 +3635,7 @@ func (m *TraceEvent_PublishMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -3641,7 +3663,7 @@ func (m *TraceEvent_PublishMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3650,6 +3672,9 @@ func (m *TraceEvent_PublishMessage) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3672,7 +3697,7 @@ func (m *TraceEvent_PublishMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -3682,6 +3707,9 @@ func (m *TraceEvent_PublishMessage) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3696,6 +3724,9 @@ func (m *TraceEvent_PublishMessage) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -3724,7 +3755,7 @@ func (m *TraceEvent_RejectMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -3752,7 +3783,7 @@ func (m *TraceEvent_RejectMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3761,6 +3792,9 @@ func (m *TraceEvent_RejectMessage) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3783,7 +3817,7 @@ func (m *TraceEvent_RejectMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3792,6 +3826,9 @@ func (m *TraceEvent_RejectMessage) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3814,7 +3851,7 @@ func (m *TraceEvent_RejectMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -3824,6 +3861,9 @@ func (m *TraceEvent_RejectMessage) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3839,6 +3879,9 @@ func (m *TraceEvent_RejectMessage) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -3867,7 +3910,7 @@ func (m *TraceEvent_DuplicateMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -3895,7 +3938,7 @@ func (m *TraceEvent_DuplicateMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3904,6 +3947,9 @@ func (m *TraceEvent_DuplicateMessage) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3926,7 +3972,7 @@ func (m *TraceEvent_DuplicateMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3935,6 +3981,9 @@ func (m *TraceEvent_DuplicateMessage) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -3952,6 +4001,9 @@ func (m *TraceEvent_DuplicateMessage) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -3980,7 +4032,7 @@ func (m *TraceEvent_DeliverMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4008,7 +4060,7 @@ func (m *TraceEvent_DeliverMessage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4017,6 +4069,9 @@ func (m *TraceEvent_DeliverMessage) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4034,6 +4089,9 @@ func (m *TraceEvent_DeliverMessage) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4062,7 +4120,7 @@ func (m *TraceEvent_AddPeer) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4090,7 +4148,7 @@ func (m *TraceEvent_AddPeer) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4099,6 +4157,9 @@ func (m *TraceEvent_AddPeer) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4121,7 +4182,7 @@ func (m *TraceEvent_AddPeer) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4131,6 +4192,9 @@ func (m *TraceEvent_AddPeer) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4146,6 +4210,9 @@ func (m *TraceEvent_AddPeer) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4174,7 +4241,7 @@ func (m *TraceEvent_RemovePeer) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4202,7 +4269,7 @@ func (m *TraceEvent_RemovePeer) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4211,6 +4278,9 @@ func (m *TraceEvent_RemovePeer) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4228,6 +4298,9 @@ func (m *TraceEvent_RemovePeer) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4256,7 +4329,7 @@ func (m *TraceEvent_RecvRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4284,7 +4357,7 @@ func (m *TraceEvent_RecvRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4293,6 +4366,9 @@ func (m *TraceEvent_RecvRPC) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4315,7 +4391,7 @@ func (m *TraceEvent_RecvRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4324,6 +4400,9 @@ func (m *TraceEvent_RecvRPC) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4343,6 +4422,9 @@ func (m *TraceEvent_RecvRPC) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4371,7 +4453,7 @@ func (m *TraceEvent_SendRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4399,7 +4481,7 @@ func (m *TraceEvent_SendRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4408,6 +4490,9 @@ func (m *TraceEvent_SendRPC) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4430,7 +4515,7 @@ func (m *TraceEvent_SendRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4439,6 +4524,9 @@ func (m *TraceEvent_SendRPC) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4458,6 +4546,9 @@ func (m *TraceEvent_SendRPC) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4486,7 +4577,7 @@ func (m *TraceEvent_DropRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4514,7 +4605,7 @@ func (m *TraceEvent_DropRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4523,6 +4614,9 @@ func (m *TraceEvent_DropRPC) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4545,7 +4639,7 @@ func (m *TraceEvent_DropRPC) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4554,6 +4648,9 @@ func (m *TraceEvent_DropRPC) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4573,6 +4670,9 @@ func (m *TraceEvent_DropRPC) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4601,7 +4701,7 @@ func (m *TraceEvent_Join) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4629,7 +4729,7 @@ func (m *TraceEvent_Join) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4639,6 +4739,9 @@ func (m *TraceEvent_Join) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4654,6 +4757,9 @@ func (m *TraceEvent_Join) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4682,7 +4788,7 @@ func (m *TraceEvent_Leave) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4710,7 +4816,7 @@ func (m *TraceEvent_Leave) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4720,6 +4826,9 @@ func (m *TraceEvent_Leave) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4735,6 +4844,9 @@ func (m *TraceEvent_Leave) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4763,7 +4875,7 @@ func (m *TraceEvent_Graft) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4791,7 +4903,7 @@ func (m *TraceEvent_Graft) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4800,6 +4912,9 @@ func (m *TraceEvent_Graft) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4822,7 +4937,7 @@ func (m *TraceEvent_Graft) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4832,6 +4947,9 @@ func (m *TraceEvent_Graft) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4847,6 +4965,9 @@ func (m *TraceEvent_Graft) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4875,7 +4996,7 @@ func (m *TraceEvent_Prune) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4903,7 +5024,7 @@ func (m *TraceEvent_Prune) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4912,6 +5033,9 @@ func (m *TraceEvent_Prune) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4934,7 +5058,7 @@ func (m *TraceEvent_Prune) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -4944,6 +5068,9 @@ func (m *TraceEvent_Prune) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -4959,6 +5086,9 @@ func (m *TraceEvent_Prune) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -4987,7 +5117,7 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5015,7 +5145,7 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5024,6 +5154,9 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5046,7 +5179,7 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5055,6 +5188,9 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5077,7 +5213,7 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5086,6 +5222,9 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5105,6 +5244,9 @@ func (m *TraceEvent_RPCMeta) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -5133,7 +5275,7 @@ func (m *TraceEvent_MessageMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5161,7 +5303,7 @@ func (m *TraceEvent_MessageMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5170,6 +5312,9 @@ func (m *TraceEvent_MessageMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5192,7 +5337,7 @@ func (m *TraceEvent_MessageMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5202,6 +5347,9 @@ func (m *TraceEvent_MessageMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5216,6 +5364,9 @@ func (m *TraceEvent_MessageMeta) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -5244,7 +5395,7 @@ func (m *TraceEvent_SubMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5272,7 +5423,7 @@ func (m *TraceEvent_SubMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= (int(b) & 0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5293,7 +5444,7 @@ func (m *TraceEvent_SubMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5303,6 +5454,9 @@ func (m *TraceEvent_SubMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5318,6 +5472,9 @@ func (m *TraceEvent_SubMeta) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -5346,7 +5503,7 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5374,7 +5531,7 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5383,6 +5540,9 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5405,7 +5565,7 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5414,6 +5574,9 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5436,7 +5599,7 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5445,6 +5608,9 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5467,7 +5633,7 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5476,6 +5642,9 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5493,6 +5662,9 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -5521,7 +5693,7 @@ func (m *TraceEvent_ControlIHaveMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5549,7 +5721,7 @@ func (m *TraceEvent_ControlIHaveMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5559,6 +5731,9 @@ func (m *TraceEvent_ControlIHaveMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5579,7 +5754,7 @@ func (m *TraceEvent_ControlIHaveMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5588,6 +5763,9 @@ func (m *TraceEvent_ControlIHaveMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5603,6 +5781,9 @@ func (m *TraceEvent_ControlIHaveMeta) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -5631,7 +5812,7 @@ func (m *TraceEvent_ControlIWantMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5659,7 +5840,7 @@ func (m *TraceEvent_ControlIWantMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5668,6 +5849,9 @@ func (m *TraceEvent_ControlIWantMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5683,6 +5867,9 @@ func (m *TraceEvent_ControlIWantMeta) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -5711,7 +5898,7 @@ func (m *TraceEvent_ControlGraftMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5739,7 +5926,7 @@ func (m *TraceEvent_ControlGraftMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5749,6 +5936,9 @@ func (m *TraceEvent_ControlGraftMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5764,6 +5954,9 @@ func (m *TraceEvent_ControlGraftMeta) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -5792,7 +5985,7 @@ func (m *TraceEvent_ControlPruneMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5820,7 +6013,7 @@ func (m *TraceEvent_ControlPruneMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5830,6 +6023,9 @@ func (m *TraceEvent_ControlPruneMeta) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5845,6 +6041,9 @@ func (m *TraceEvent_ControlPruneMeta) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTrace + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -5873,7 +6072,7 @@ func (m *TraceEventBatch) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -5901,7 +6100,7 @@ func (m *TraceEventBatch) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5910,6 +6109,9 @@ func (m *TraceEventBatch) Unmarshal(dAtA []byte) error { return ErrInvalidLengthTrace } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTrace + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -5927,86 +6129,7 @@ func (m *TraceEventBatch) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthTrace } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CompressedTraceEventBatch) 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 ErrIntOverflowTrace - } - 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: CompressedTraceEventBatch: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CompressedTraceEventBatch: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTrace - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTrace - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTrace(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { + if (iNdEx + skippy) < 0 { return ErrInvalidLengthTrace } if (iNdEx + skippy) > l { @@ -6076,10 +6199,13 @@ func skipTrace(dAtA []byte) (n int, err error) { break } } - iNdEx += length if length < 0 { return 0, ErrInvalidLengthTrace } + iNdEx += length + if iNdEx < 0 { + return 0, ErrInvalidLengthTrace + } return iNdEx, nil case 3: for { @@ -6108,6 +6234,9 @@ func skipTrace(dAtA []byte) (n int, err error) { return 0, err } iNdEx = start + next + if iNdEx < 0 { + return 0, ErrInvalidLengthTrace + } } return iNdEx, nil case 4: @@ -6126,72 +6255,3 @@ var ( ErrInvalidLengthTrace = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowTrace = fmt.Errorf("proto: integer overflow") ) - -func init() { proto.RegisterFile("trace.proto", fileDescriptor_trace_a154d83c271edb68) } - -var fileDescriptor_trace_a154d83c271edb68 = []byte{ - // 1006 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xdd, 0x6e, 0xe3, 0x44, - 0x14, 0xc7, 0x71, 0x3e, 0x36, 0xc9, 0x49, 0x9a, 0x9a, 0x81, 0x22, 0x63, 0x76, 0xab, 0x10, 0x56, - 0xab, 0x48, 0x48, 0x41, 0x5b, 0x09, 0xed, 0x05, 0xbb, 0x88, 0x34, 0x76, 0xdb, 0x54, 0x69, 0x6b, - 0x9d, 0xa4, 0xe5, 0xb2, 0x38, 0xc9, 0xb0, 0xf5, 0x2a, 0xb1, 0x2d, 0x7b, 0x12, 0xb4, 0x0f, 0xc0, - 0xbb, 0xed, 0x1d, 0x3c, 0x02, 0xea, 0x15, 0x8f, 0x81, 0x66, 0xc6, 0x8e, 0xe3, 0xd4, 0xf1, 0x2e, - 0x0b, 0x77, 0x73, 0xc6, 0xff, 0xdf, 0x99, 0xaf, 0xf3, 0x3f, 0x32, 0xd4, 0x59, 0x60, 0x4f, 0x69, - 0xd7, 0x0f, 0x3c, 0xe6, 0x91, 0x9a, 0xbf, 0x9c, 0x84, 0xcb, 0x49, 0xd7, 0x9f, 0xb4, 0xff, 0x3e, - 0x00, 0x18, 0xf3, 0x4f, 0xe6, 0x8a, 0xba, 0x8c, 0x74, 0xa1, 0xc4, 0xde, 0xfa, 0x54, 0x53, 0x5a, - 0x4a, 0xa7, 0x79, 0xa4, 0x77, 0xd7, 0xc2, 0x6e, 0x22, 0xea, 0x8e, 0xdf, 0xfa, 0x14, 0x85, 0x8e, - 0x7c, 0x01, 0x8f, 0x7c, 0x4a, 0x83, 0x81, 0xa1, 0x15, 0x5a, 0x4a, 0xa7, 0x81, 0x51, 0x44, 0x1e, - 0x43, 0x8d, 0x39, 0x0b, 0x1a, 0x32, 0x7b, 0xe1, 0x6b, 0xc5, 0x96, 0xd2, 0x29, 0x62, 0x32, 0x41, - 0x86, 0xd0, 0xf4, 0x97, 0x93, 0xb9, 0x13, 0xde, 0x5d, 0xd0, 0x30, 0xb4, 0x5f, 0x53, 0xad, 0xd4, - 0x52, 0x3a, 0xf5, 0xa3, 0xa7, 0xd9, 0xeb, 0x59, 0x29, 0x2d, 0x6e, 0xb1, 0x64, 0x00, 0x7b, 0x01, - 0x7d, 0x43, 0xa7, 0x2c, 0x4e, 0x56, 0x16, 0xc9, 0xbe, 0xc9, 0x4e, 0x86, 0x9b, 0x52, 0x4c, 0x93, - 0x04, 0x41, 0x9d, 0x2d, 0xfd, 0xb9, 0x33, 0xb5, 0x19, 0x8d, 0xb3, 0x3d, 0x12, 0xd9, 0x9e, 0x65, - 0x67, 0x33, 0xb6, 0xd4, 0xf8, 0x80, 0xe7, 0x87, 0x9d, 0xd1, 0xb9, 0xb3, 0xa2, 0x41, 0x9c, 0xb1, - 0x92, 0x77, 0x58, 0x23, 0xa5, 0xc5, 0x2d, 0x96, 0xbc, 0x80, 0x8a, 0x3d, 0x9b, 0x59, 0x94, 0x06, - 0x5a, 0x55, 0xa4, 0x79, 0x92, 0x9d, 0xa6, 0x27, 0x45, 0x18, 0xab, 0xc9, 0x4f, 0x00, 0x01, 0x5d, - 0x78, 0x2b, 0x2a, 0xd8, 0x9a, 0x60, 0x5b, 0xbb, 0xae, 0x28, 0xd6, 0xe1, 0x06, 0xc3, 0x97, 0x0e, - 0xe8, 0x74, 0x85, 0x56, 0x5f, 0x83, 0xbc, 0xa5, 0x51, 0x8a, 0x30, 0x56, 0x73, 0x30, 0xa4, 0xee, - 0x8c, 0x83, 0xf5, 0x3c, 0x70, 0x24, 0x45, 0x18, 0xab, 0x39, 0x38, 0x0b, 0x3c, 0x9f, 0x83, 0x8d, - 0x3c, 0xd0, 0x90, 0x22, 0x8c, 0xd5, 0xbc, 0x8c, 0xdf, 0x78, 0x8e, 0xab, 0xed, 0x09, 0x6a, 0x47, - 0x19, 0x9f, 0x7b, 0x8e, 0x8b, 0x42, 0x47, 0x9e, 0x43, 0x79, 0x4e, 0xed, 0x15, 0xd5, 0x9a, 0x02, - 0xf8, 0x2a, 0x1b, 0x18, 0x72, 0x09, 0x4a, 0x25, 0x47, 0x5e, 0x07, 0xf6, 0xaf, 0x4c, 0xdb, 0xcf, - 0x43, 0x4e, 0xb9, 0x04, 0xa5, 0x92, 0x23, 0x7e, 0xb0, 0x74, 0xa9, 0xa6, 0xe6, 0x21, 0x16, 0x97, - 0xa0, 0x54, 0xea, 0x27, 0xd0, 0x4c, 0x57, 0x3f, 0x77, 0xd6, 0x42, 0x0e, 0x07, 0x86, 0xb0, 0x69, - 0x03, 0x93, 0x09, 0xee, 0x47, 0xe6, 0xf9, 0xce, 0x34, 0xd4, 0x0a, 0xad, 0x62, 0xa7, 0x86, 0x51, - 0xa4, 0x3b, 0xb0, 0x97, 0x2a, 0xfc, 0xf7, 0xa4, 0x69, 0x43, 0x23, 0xa0, 0x53, 0xea, 0xac, 0xe8, - 0xec, 0x24, 0xf0, 0x16, 0x91, 0xb9, 0x53, 0x73, 0x7c, 0xa9, 0x80, 0xda, 0xa1, 0xe7, 0x0a, 0x7f, - 0xd7, 0x30, 0x8a, 0xf4, 0x31, 0xa8, 0xdb, 0xae, 0xf8, 0xef, 0xab, 0xe9, 0x5d, 0x68, 0xa6, 0x9d, - 0x91, 0x9f, 0x53, 0x7f, 0x01, 0x95, 0xc8, 0x02, 0x1b, 0x3d, 0x4a, 0x49, 0xf5, 0xa8, 0xcf, 0xf9, - 0x73, 0x78, 0xcc, 0x13, 0xeb, 0xd5, 0x50, 0x06, 0xfa, 0x53, 0x80, 0xa4, 0xfe, 0x77, 0xb1, 0xfa, - 0x2f, 0x50, 0x89, 0xca, 0xfc, 0xc1, 0xee, 0x95, 0x8c, 0xbb, 0x7a, 0x0e, 0xa5, 0x05, 0x65, 0xb6, - 0x58, 0x69, 0xb7, 0x6f, 0xac, 0xfe, 0x05, 0x65, 0x36, 0x0a, 0xa9, 0x3e, 0x86, 0x4a, 0xe4, 0x07, - 0xbe, 0x09, 0xee, 0x88, 0xb1, 0x17, 0x6f, 0x42, 0x46, 0x1f, 0x99, 0x35, 0x32, 0xcb, 0xff, 0x99, - 0xf5, 0x31, 0x94, 0xb8, 0x99, 0xf8, 0x8d, 0x8a, 0x7a, 0x13, 0x19, 0x6b, 0x28, 0x03, 0xfd, 0x09, - 0x94, 0x85, 0x73, 0x92, 0xcf, 0x85, 0xcd, 0xcf, 0xdf, 0x43, 0x59, 0xb8, 0x24, 0xef, 0x9d, 0xb2, - 0x31, 0xe1, 0x94, 0x7f, 0x89, 0xbd, 0x53, 0xa0, 0x12, 0x6d, 0x9e, 0xbc, 0x82, 0x6a, 0x54, 0x30, - 0xa1, 0xa6, 0xb4, 0x8a, 0x9d, 0xfa, 0xd1, 0xd7, 0xd9, 0xa7, 0x8d, 0x4a, 0x4e, 0x9c, 0x78, 0x8d, - 0x90, 0x1e, 0x34, 0xc2, 0xe5, 0x24, 0x9c, 0x06, 0x8e, 0xcf, 0x1c, 0xcf, 0x15, 0x8e, 0xdb, 0xdd, - 0xdb, 0x96, 0x13, 0x81, 0xa7, 0x10, 0xf2, 0x03, 0x54, 0xa6, 0x9e, 0xcb, 0x02, 0x6f, 0x2e, 0x4c, - 0xb4, 0x73, 0x03, 0x7d, 0x29, 0x12, 0x19, 0x62, 0x42, 0xef, 0x43, 0x7d, 0x63, 0x63, 0x1f, 0xd9, - 0x18, 0x5e, 0x41, 0x25, 0xda, 0x1a, 0x4f, 0x10, 0x6d, 0x6e, 0x22, 0x7f, 0x00, 0xaa, 0x98, 0x4c, - 0xec, 0xb8, 0xce, 0xdf, 0x0b, 0x50, 0xdf, 0xd8, 0x1c, 0x79, 0x09, 0x65, 0xe7, 0x8e, 0x37, 0x52, - 0x79, 0x9f, 0xcf, 0x72, 0x8f, 0x33, 0x38, 0xb3, 0x57, 0xf2, 0x52, 0x25, 0x24, 0xe8, 0xdf, 0x6c, - 0x97, 0x45, 0x57, 0xf9, 0x1e, 0xfa, 0x67, 0xdb, 0x65, 0x11, 0xcd, 0x21, 0x4e, 0xcb, 0x8e, 0x5c, - 0xfc, 0x00, 0x5a, 0x94, 0x9c, 0xa4, 0x65, 0x73, 0x7e, 0x19, 0x37, 0xe7, 0xd2, 0x07, 0xd0, 0xa2, - 0xf2, 0x24, 0x2d, 0xfb, 0xf4, 0x19, 0xa8, 0xdb, 0x87, 0xca, 0x76, 0x03, 0x39, 0x04, 0x58, 0xbf, - 0x8a, 0x7c, 0x8c, 0x06, 0x6e, 0xcc, 0xe8, 0x47, 0x49, 0xa6, 0xf8, 0x80, 0x5b, 0x8c, 0xf2, 0x80, - 0xe9, 0xac, 0x99, 0xf5, 0xb1, 0x76, 0x78, 0x31, 0x51, 0xae, 0x8f, 0x90, 0xad, 0x6c, 0xff, 0xa1, - 0x40, 0x89, 0xff, 0xe8, 0x91, 0xcf, 0x60, 0xdf, 0xba, 0x3e, 0x1e, 0x0e, 0x46, 0x67, 0xb7, 0x17, - 0xe6, 0x68, 0xd4, 0x3b, 0x35, 0xd5, 0x4f, 0x08, 0x81, 0x26, 0x9a, 0xe7, 0x66, 0x7f, 0xbc, 0x9e, - 0x53, 0xc8, 0x01, 0x7c, 0x6a, 0x5c, 0x5b, 0xc3, 0x41, 0xbf, 0x37, 0x36, 0xd7, 0xd3, 0x05, 0xce, - 0x1b, 0xe6, 0x70, 0x70, 0x63, 0xe2, 0x7a, 0xb2, 0x48, 0x1a, 0x50, 0xed, 0x19, 0xc6, 0xad, 0x65, - 0x9a, 0xa8, 0x96, 0xc8, 0x3e, 0xd4, 0xd1, 0xbc, 0xb8, 0xba, 0x31, 0xe5, 0x44, 0x99, 0x7f, 0x46, - 0xb3, 0x7f, 0x73, 0x8b, 0x56, 0x5f, 0x7d, 0xc4, 0xa3, 0x91, 0x79, 0x69, 0x88, 0xa8, 0xc2, 0x23, - 0x03, 0xaf, 0x2c, 0x11, 0x55, 0x49, 0x15, 0x4a, 0xe7, 0x57, 0x83, 0x4b, 0xb5, 0x46, 0x6a, 0x50, - 0x1e, 0x9a, 0xbd, 0x1b, 0x53, 0x05, 0x3e, 0x3c, 0xc5, 0xde, 0xc9, 0x58, 0xad, 0xf3, 0xa1, 0x85, - 0xd7, 0x97, 0xa6, 0xda, 0x68, 0xff, 0x08, 0xfb, 0xc9, 0x4b, 0x1e, 0xdb, 0x6c, 0x7a, 0x47, 0xbe, - 0x85, 0xf2, 0x84, 0x0f, 0xa2, 0x72, 0x3d, 0xc8, 0x7c, 0x74, 0x94, 0x9a, 0xf6, 0x77, 0xf0, 0x65, - 0xdf, 0x5b, 0xf8, 0x01, 0x0d, 0x43, 0x3a, 0xdb, 0xce, 0x44, 0xa0, 0x34, 0xb3, 0x99, 0x1d, 0x19, - 0x4f, 0x8c, 0x8f, 0x1b, 0xef, 0xee, 0x0f, 0x95, 0x3f, 0xef, 0x0f, 0x95, 0xbf, 0xee, 0x0f, 0x95, - 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x80, 0x70, 0x3c, 0x82, 0x0b, 0x00, 0x00, -} diff --git a/pb/trace.proto b/pb/trace.proto index 7599d33..1b655b0 100644 --- a/pb/trace.proto +++ b/pb/trace.proto @@ -143,7 +143,3 @@ message TraceEvent { message TraceEventBatch { repeated TraceEvent batch = 1; } - -message CompressedTraceEventBatch { - optional bytes data = 1; -} From abe4763c012b99b75768a2a9c312d4cc4a307813 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 18 Nov 2019 17:13:43 +0200 Subject: [PATCH 18/25] compress entire stream in remote tracer --- tracer.go | 65 +++++++++++++++++++++---------------------------------- 1 file changed, 25 insertions(+), 40 deletions(-) diff --git a/tracer.go b/tracer.go index dbef80a..3893cb3 100644 --- a/tracer.go +++ b/tracer.go @@ -1,7 +1,6 @@ package pubsub import ( - "bytes" "compress/gzip" "context" "encoding/json" @@ -173,7 +172,10 @@ func (t *RemoteTracer) doWrite() { return } - w := ggio.NewDelimitedWriter(s) + var batch pb.TraceEventBatch + + gzipW := gzip.NewWriter(s) + w := ggio.NewDelimitedWriter(gzipW) for { _, ok := <-t.ch @@ -196,53 +198,36 @@ func (t *RemoteTracer) doWrite() { goto end } - { - batch := &pb.TraceEventBatch{Batch: buf} - blob, err := batch.Marshal() - if err != nil { - log.Errorf("error marshalling trace event batch: %s", err.Error()) - goto end - } + batch.Batch = buf - // compress batch - var cbuf bytes.Buffer - gzipW := gzip.NewWriter(&cbuf) - _, err = gzipW.Write(blob) - if err != nil { - log.Errorf("error compressing trace event batch: %s", err.Error()) - goto end - } - err = gzipW.Close() - if err != nil { - log.Errorf("error compressing trace event batch: %s", err.Error()) - goto end - } + err = w.WriteMsg(&batch) + if err != nil { + log.Errorf("error writing trace event batch: %s", err) + goto end + } - cblob := cbuf.Bytes() - cbatch := &pb.CompressedTraceEventBatch{Data: cblob} - err = w.WriteMsg(cbatch) - if err != nil { - log.Errorf("error writing trace event data: %s", err.Error()) - if !ok { - goto end - } - - // reset output - s.Reset() - s, err = t.openStream() - if err != nil { - log.Errorf("error opening remote tracer stream: %s", err.Error()) - return - } - w = ggio.NewDelimitedWriter(s) - } + err = gzipW.Flush() + if err != nil { + log.Errorf("error flushin gzip stream: %s", err) + goto end } end: if !ok { + gzipW.Close() helpers.FullClose(s) return } + + if err != nil { + s, err = t.openStream() + if err != nil { + log.Errorf("error opening remote tracer stream: %s", err.Error()) + return + } + + gzipW.Reset(s) + } } } From cce30a4d6a065b2b7f115057b0c1c2b5742c3247 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 18 Nov 2019 17:33:53 +0200 Subject: [PATCH 19/25] reset remote tracer stream on errors --- tracer.go | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tracer.go b/tracer.go index 3893cb3..5d7619d 100644 --- a/tracer.go +++ b/tracer.go @@ -214,12 +214,17 @@ func (t *RemoteTracer) doWrite() { end: if !ok { - gzipW.Close() - helpers.FullClose(s) + if err != nil { + s.Reset() + } else { + gzipW.Close() + helpers.FullClose(s) + } return } if err != nil { + s.Reset() s, err = t.openStream() if err != nil { log.Errorf("error opening remote tracer stream: %s", err.Error()) From 91527e2d10290e045dfa12d0522924cf29420c05 Mon Sep 17 00:00:00 2001 From: vyzo Date: Mon, 18 Nov 2019 22:01:31 +0200 Subject: [PATCH 20/25] lossy tracing for remote tracers Don't accumulate memory if the tracer is being slow or unavailable, just drop the trace and log. --- tracer.go | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/tracer.go b/tracer.go index 5d7619d..724fc15 100644 --- a/tracer.go +++ b/tracer.go @@ -20,15 +20,22 @@ import ( ggio "github.com/gogo/protobuf/io" ) +var TraceBufferSize = 1 << 16 // 64K ought to be enough for everyone; famous last words. + type basicTracer struct { - ch chan struct{} - mx sync.Mutex - buf []*pb.TraceEvent + ch chan struct{} + mx sync.Mutex + buf []*pb.TraceEvent + lossy bool } func (t *basicTracer) Trace(evt *pb.TraceEvent) { t.mx.Lock() - t.buf = append(t.buf, evt) + if t.lossy && len(t.buf) > TraceBufferSize { + log.Warningf("trace buffer overflow; dropping trace event") + } else { + t.buf = append(t.buf, evt) + } t.mx.Unlock() select { @@ -158,7 +165,7 @@ type RemoteTracer struct { // NewRemoteTracer constructs a RemoteTracer, tracing to the peer identified by pi func NewRemoteTracer(ctx context.Context, host host.Host, pi peer.AddrInfo) (*RemoteTracer, error) { - tr := &RemoteTracer{ctx: ctx, host: host, pi: pi, basicTracer: basicTracer{ch: make(chan struct{}, 1)}} + tr := &RemoteTracer{ctx: ctx, host: host, pi: pi, basicTracer: basicTracer{ch: make(chan struct{}, 1), lossy: true}} go tr.doWrite() return tr, nil } From 24a1181b9a66dc36f3db0deb1ab3b5c6ac82aa96 Mon Sep 17 00:00:00 2001 From: vyzo Date: Tue, 19 Nov 2019 00:07:57 +0200 Subject: [PATCH 21/25] move niling of trace buffer to the end this avoids holding on memory while we are waiting. --- tracer.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tracer.go b/tracer.go index 724fc15..809cbbe 100644 --- a/tracer.go +++ b/tracer.go @@ -187,11 +187,6 @@ func (t *RemoteTracer) doWrite() { for { _, ok := <-t.ch - // nil out the buffer to gc events when swapping buffers - for i := range buf { - buf[i] = nil - } - // wait a bit to accumulate a batch time.Sleep(time.Second) @@ -220,6 +215,11 @@ func (t *RemoteTracer) doWrite() { } end: + // nil out the buffer to gc consumed events + for i := range buf { + buf[i] = nil + } + if !ok { if err != nil { s.Reset() From 7a5aaa8d1cba71c9583052fc9719658acb5a14c2 Mon Sep 17 00:00:00 2001 From: vyzo Date: Tue, 19 Nov 2019 00:18:10 +0200 Subject: [PATCH 22/25] don't blanket wait for 1s to accumulate a batch. Instead check the batch size and poll every 100ms (up to 1s) until the minimum batch size is accumulated. --- tracer.go | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/tracer.go b/tracer.go index 809cbbe..c56fbe3 100644 --- a/tracer.go +++ b/tracer.go @@ -21,6 +21,7 @@ import ( ) var TraceBufferSize = 1 << 16 // 64K ought to be enough for everyone; famous last words. +var MinTraceBatchSize = 16 type basicTracer struct { ch chan struct{} @@ -187,10 +188,17 @@ func (t *RemoteTracer) doWrite() { for { _, ok := <-t.ch - // wait a bit to accumulate a batch - time.Sleep(time.Second) + // deadline for batch accumulation + deadline := time.Now().Add(time.Second) + again: t.mx.Lock() + if len(t.buf) < MinTraceBatchSize && time.Now().Before(deadline) { + t.mx.Unlock() + time.Sleep(100 * time.Millisecond) + goto again + } + tmp := t.buf t.buf = buf[:0] buf = tmp From 40e5a49d1bfa30c7592ee1da10e565dbd1bb9164 Mon Sep 17 00:00:00 2001 From: vyzo Date: Tue, 19 Nov 2019 00:26:06 +0200 Subject: [PATCH 23/25] store the remote trace peer address in the peerstore that way we don't have to connect every time we open the stream. --- tracer.go | 38 +++++++------------------------------- 1 file changed, 7 insertions(+), 31 deletions(-) diff --git a/tracer.go b/tracer.go index c56fbe3..1585e46 100644 --- a/tracer.go +++ b/tracer.go @@ -15,6 +15,7 @@ import ( "github.com/libp2p/go-libp2p-core/host" "github.com/libp2p/go-libp2p-core/network" "github.com/libp2p/go-libp2p-core/peer" + "github.com/libp2p/go-libp2p-core/peerstore" "github.com/libp2p/go-libp2p-core/protocol" ggio "github.com/gogo/protobuf/io" @@ -161,12 +162,15 @@ type RemoteTracer struct { basicTracer ctx context.Context host host.Host - pi peer.AddrInfo + peer peer.ID } // NewRemoteTracer constructs a RemoteTracer, tracing to the peer identified by pi func NewRemoteTracer(ctx context.Context, host host.Host, pi peer.AddrInfo) (*RemoteTracer, error) { - tr := &RemoteTracer{ctx: ctx, host: host, pi: pi, basicTracer: basicTracer{ch: make(chan struct{}, 1), lossy: true}} + tr := &RemoteTracer{ctx: ctx, host: host, peer: pi.ID, basicTracer: basicTracer{ch: make(chan struct{}, 1), lossy: true}} + for _, addr := range pi.Addrs { + host.Peerstore().AddAddr(pi.ID, addr, peerstore.PermanentAddrTTL) + } go tr.doWrite() return tr, nil } @@ -251,38 +255,10 @@ func (t *RemoteTracer) doWrite() { } } -func (t *RemoteTracer) connect() error { - for { - ctx, cancel := context.WithTimeout(t.ctx, time.Minute) - err := t.host.Connect(ctx, t.pi) - cancel() - if err != nil { - if t.ctx.Err() != nil { - return err - } - - // wait a minute and try again, to account for transient server downtime - select { - case <-time.After(time.Minute): - continue - case <-t.ctx.Done(): - return t.ctx.Err() - } - } - - return nil - } -} - func (t *RemoteTracer) openStream() (network.Stream, error) { for { - err := t.connect() - if err != nil { - return nil, err - } - ctx, cancel := context.WithTimeout(t.ctx, time.Minute) - s, err := t.host.NewStream(ctx, t.pi.ID, RemoteTracerProtoID) + s, err := t.host.NewStream(ctx, t.peer, RemoteTracerProtoID) cancel() if err != nil { if t.ctx.Err() != nil { From cd7f42e1d70efb4bd532e58bc5bf2bb7cf908780 Mon Sep 17 00:00:00 2001 From: vyzo Date: Tue, 19 Nov 2019 00:29:23 +0200 Subject: [PATCH 24/25] make tracer.Close safer --- tracer.go | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/tracer.go b/tracer.go index 1585e46..a4d3c9b 100644 --- a/tracer.go +++ b/tracer.go @@ -25,14 +25,20 @@ var TraceBufferSize = 1 << 16 // 64K ought to be enough for everyone; famous las var MinTraceBatchSize = 16 type basicTracer struct { - ch chan struct{} - mx sync.Mutex - buf []*pb.TraceEvent - lossy bool + ch chan struct{} + mx sync.Mutex + buf []*pb.TraceEvent + lossy bool + closed bool } func (t *basicTracer) Trace(evt *pb.TraceEvent) { t.mx.Lock() + if t.closed { + t.mx.Unlock() + return + } + if t.lossy && len(t.buf) > TraceBufferSize { log.Warningf("trace buffer overflow; dropping trace event") } else { @@ -47,7 +53,12 @@ func (t *basicTracer) Trace(evt *pb.TraceEvent) { } func (t *basicTracer) Close() { - close(t.ch) + t.mx.Lock() + defer t.mx.Unlock() + if !t.closed { + t.closed = true + close(t.ch) + } } // JSONTracer is a tracer that writes events to a file, encoded in ndjson. From 7065297ac631a245669eb6369c0188f41f89a411 Mon Sep 17 00:00:00 2001 From: vyzo Date: Tue, 19 Nov 2019 02:28:23 +0200 Subject: [PATCH 25/25] nits and beauty --- tracer.go | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/tracer.go b/tracer.go index a4d3c9b..a379c89 100644 --- a/tracer.go +++ b/tracer.go @@ -179,9 +179,7 @@ type RemoteTracer struct { // NewRemoteTracer constructs a RemoteTracer, tracing to the peer identified by pi func NewRemoteTracer(ctx context.Context, host host.Host, pi peer.AddrInfo) (*RemoteTracer, error) { tr := &RemoteTracer{ctx: ctx, host: host, peer: pi.ID, basicTracer: basicTracer{ch: make(chan struct{}, 1), lossy: true}} - for _, addr := range pi.Addrs { - host.Peerstore().AddAddr(pi.ID, addr, peerstore.PermanentAddrTTL) - } + host.Peerstore().AddAddrs(pi.ID, pi.Addrs, peerstore.PermanentAddrTTL) go tr.doWrite() return tr, nil } @@ -206,12 +204,11 @@ func (t *RemoteTracer) doWrite() { // deadline for batch accumulation deadline := time.Now().Add(time.Second) - again: t.mx.Lock() - if len(t.buf) < MinTraceBatchSize && time.Now().Before(deadline) { + for len(t.buf) < MinTraceBatchSize && time.Now().Before(deadline) { t.mx.Unlock() time.Sleep(100 * time.Millisecond) - goto again + t.mx.Lock() } tmp := t.buf