cerc-io/lotus
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity

Use tuple encoding

Browse Source 
Signed-off-by: Jakub Sztandera <kubuxu@protocol.ai>
This commit is contained in:
Jakub Sztandera 2020-02-12 19:23:15 +01:00
parent 50702f309f
commit 8610bcbec3
3 changed files with 132 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gen/main.go
View File

@ -59,7 +59,7 @@ func main() {
os.Exit(1) os.Exit(1)
} }
err = gen.WriteMapEncodersToFile("./node/hello/cbor_gen.go", "hello", err = gen.WriteTupleEncodersToFile("./node/hello/cbor_gen.go", "hello",
hello.HelloMessage{}, hello.HelloMessage{},
hello.LatencyMessage{}, hello.LatencyMessage{},
) )

320
node/hello/cbor_gen.go
View File

@ -18,22 +18,11 @@ func (t *HelloMessage) MarshalCBOR(w io.Writer) error {
_, err := w.Write(cbg.CborNull) _, err := w.Write(cbg.CborNull)
return err return err
} }
if _, err := w.Write([]byte{164}); err != nil { if _, err := w.Write([]byte{132}); err != nil {
return err return err
} }
// t.HeaviestTipSet ([]cid.Cid) (slice) // t.HeaviestTipSet ([]cid.Cid) (slice)
if len("HeaviestTipSet") > cbg.MaxLength {
return xerrors.Errorf("Value in field \"HeaviestTipSet\" was too long")
}
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("HeaviestTipSet")))); err != nil {
return err
}
if _, err := w.Write([]byte("HeaviestTipSet")); err != nil {
return err
}
if len(t.HeaviestTipSet) > cbg.MaxLength { if len(t.HeaviestTipSet) > cbg.MaxLength {
return xerrors.Errorf("Slice value in field t.HeaviestTipSet was too long") return xerrors.Errorf("Slice value in field t.HeaviestTipSet was too long")
} }
@ -48,48 +37,16 @@ func (t *HelloMessage) MarshalCBOR(w io.Writer) error {
} }
// t.HeaviestTipSetHeight (uint64) (uint64) // t.HeaviestTipSetHeight (uint64) (uint64)
if len("HeaviestTipSetHeight") > cbg.MaxLength {
return xerrors.Errorf("Value in field \"HeaviestTipSetHeight\" was too long")
}
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("HeaviestTipSetHeight")))); err != nil {
return err
}
if _, err := w.Write([]byte("HeaviestTipSetHeight")); err != nil {
return err
}
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.HeaviestTipSetHeight))); err != nil { if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.HeaviestTipSetHeight))); err != nil {
return err return err
} }
// t.HeaviestTipSetWeight (types.BigInt) (struct) // t.HeaviestTipSetWeight (types.BigInt) (struct)
if len("HeaviestTipSetWeight") > cbg.MaxLength {
return xerrors.Errorf("Value in field \"HeaviestTipSetWeight\" was too long")
}
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("HeaviestTipSetWeight")))); err != nil {
return err
}
if _, err := w.Write([]byte("HeaviestTipSetWeight")); err != nil {
return err
}
if err := t.HeaviestTipSetWeight.MarshalCBOR(w); err != nil { if err := t.HeaviestTipSetWeight.MarshalCBOR(w); err != nil {
return err return err
} }
// t.GenesisHash (cid.Cid) (struct) // t.GenesisHash (cid.Cid) (struct)
if len("GenesisHash") > cbg.MaxLength {
return xerrors.Errorf("Value in field \"GenesisHash\" was too long")
}
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("GenesisHash")))); err != nil {
return err
}
if _, err := w.Write([]byte("GenesisHash")); err != nil {
return err
}
if err := cbg.WriteCid(w, t.GenesisHash); err != nil { if err := cbg.WriteCid(w, t.GenesisHash); err != nil {
return xerrors.Errorf("failed to write cid field t.GenesisHash: %w", err) return xerrors.Errorf("failed to write cid field t.GenesisHash: %w", err)
@ -105,137 +62,103 @@ func (t *HelloMessage) UnmarshalCBOR(r io.Reader) error {
if err != nil { if err != nil {
return err return err
} }
if maj != cbg.MajMap { if maj != cbg.MajArray {
return fmt.Errorf("cbor input should be of type map") return fmt.Errorf("cbor input should be of type array")
}
if extra != 4 {
return fmt.Errorf("cbor input had wrong number of fields")
}
// t.HeaviestTipSet ([]cid.Cid) (slice)
maj, extra, err = cbg.CborReadHeader(br)
if err != nil {
return err
} }
if extra > cbg.MaxLength { if extra > cbg.MaxLength {
return fmt.Errorf("HelloMessage: map struct too large (%d)", extra) return fmt.Errorf("t.HeaviestTipSet: array too large (%d)", extra)
} }
var name string if maj != cbg.MajArray {
n := extra return fmt.Errorf("expected cbor array")
}
if extra > 0 {
t.HeaviestTipSet = make([]cid.Cid, extra)
}
for i := 0; i < int(extra); i++ {
for i := uint64(0); i < n; i++ { c, err := cbg.ReadCid(br)
if err != nil {
{ return xerrors.Errorf("reading cid field t.HeaviestTipSet failed: %w", err)
sval, err := cbg.ReadString(br)
if err != nil {
return err
}
name = string(sval)
}
switch name {
// t.HeaviestTipSet ([]cid.Cid) (slice)
case "HeaviestTipSet":
maj, extra, err = cbg.CborReadHeader(br)
if err != nil {
return err
}
if extra > cbg.MaxLength {
return fmt.Errorf("t.HeaviestTipSet: array too large (%d)", extra)
}
if maj != cbg.MajArray {
return fmt.Errorf("expected cbor array")
}
if extra > 0 {
t.HeaviestTipSet = make([]cid.Cid, extra)
}
for i := 0; i < int(extra); i++ {
c, err := cbg.ReadCid(br)
if err != nil {
return xerrors.Errorf("reading cid field t.HeaviestTipSet failed: %w", err)
}
t.HeaviestTipSet[i] = c
}
// t.HeaviestTipSetHeight (uint64) (uint64)
case "HeaviestTipSetHeight":
maj, extra, err = cbg.CborReadHeader(br)
if err != nil {
return err
}
if maj != cbg.MajUnsignedInt {
return fmt.Errorf("wrong type for uint64 field")
}
t.HeaviestTipSetHeight = uint64(extra)
// t.HeaviestTipSetWeight (types.BigInt) (struct)
case "HeaviestTipSetWeight":
{
if err := t.HeaviestTipSetWeight.UnmarshalCBOR(br); err != nil {
return err
}
}
// t.GenesisHash (cid.Cid) (struct)
case "GenesisHash":
{
c, err := cbg.ReadCid(br)
if err != nil {
return xerrors.Errorf("failed to read cid field t.GenesisHash: %w", err)
}
t.GenesisHash = c
}
default:
return fmt.Errorf("unknown struct field %d: '%s'", i, name)
} }
t.HeaviestTipSet[i] = c
} }
// t.HeaviestTipSetHeight (uint64) (uint64)
maj, extra, err = cbg.CborReadHeader(br)
if err != nil {
return err
}
if maj != cbg.MajUnsignedInt {
return fmt.Errorf("wrong type for uint64 field")
}
t.HeaviestTipSetHeight = uint64(extra)
// t.HeaviestTipSetWeight (types.BigInt) (struct)
{
if err := t.HeaviestTipSetWeight.UnmarshalCBOR(br); err != nil {
return err
}
}
// t.GenesisHash (cid.Cid) (struct)
{
c, err := cbg.ReadCid(br)
if err != nil {
return xerrors.Errorf("failed to read cid field t.GenesisHash: %w", err)
}
t.GenesisHash = c
}
return nil return nil
} }
func (t *LatencyMessage) MarshalCBOR(w io.Writer) error { func (t *LatencyMessage) MarshalCBOR(w io.Writer) error {
if t == nil { if t == nil {
_, err := w.Write(cbg.CborNull) _, err := w.Write(cbg.CborNull)
return err return err
} }
if _, err := w.Write([]byte{162}); err != nil { if _, err := w.Write([]byte{130}); err != nil {
return err return err
} }
// t.TArrial (uint64) (uint64) // t.TArrial (int64) (int64)
if len("TArrial") > cbg.MaxLength { if t.TArrial >= 0 {
return xerrors.Errorf("Value in field \"TArrial\" was too long") if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TArrial))); err != nil {
return err
}
} else {
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.TArrial)-1)); err != nil {
return err
}
} }
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("TArrial")))); err != nil { // t.TSent (int64) (int64)
return err if t.TSent >= 0 {
} if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TSent))); err != nil {
if _, err := w.Write([]byte("TArrial")); err != nil { return err
return err }
} } else {
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.TSent)-1)); err != nil {
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TArrial))); err != nil { return err
return err }
}
// t.TSent (uint64) (uint64)
if len("TSent") > cbg.MaxLength {
return xerrors.Errorf("Value in field \"TSent\" was too long")
}
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("TSent")))); err != nil {
return err
}
if _, err := w.Write([]byte("TSent")); err != nil {
return err
}
if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TSent))); err != nil {
return err
} }
return nil return nil
} }
@ -247,56 +170,63 @@ func (t *LatencyMessage) UnmarshalCBOR(r io.Reader) error {
if err != nil { if err != nil {
return err return err
} }
if maj != cbg.MajMap { if maj != cbg.MajArray {
return fmt.Errorf("cbor input should be of type map") return fmt.Errorf("cbor input should be of type array")
} }
if extra > cbg.MaxLength { if extra != 2 {
return fmt.Errorf("LatencyMessage: map struct too large (%d)", extra) return fmt.Errorf("cbor input had wrong number of fields")
} }
var name string // t.TArrial (int64) (int64)
n := extra {
maj, extra, err := cbg.CborReadHeader(br)
for i := uint64(0); i < n; i++ { var extraI int64
if err != nil {
{ return err
sval, err := cbg.ReadString(br)
if err != nil {
return err
}
name = string(sval)
} }
switch maj {
switch name { case cbg.MajUnsignedInt:
// t.TArrial (uint64) (uint64) extraI = int64(extra)
case "TArrial": if extraI < 0 {
return fmt.Errorf("int64 positive overflow")
maj, extra, err = cbg.CborReadHeader(br)
if err != nil {
return err
} }
if maj != cbg.MajUnsignedInt { case cbg.MajNegativeInt:
return fmt.Errorf("wrong type for uint64 field") extraI = int64(extra)
if extraI < 0 {
return fmt.Errorf("int64 negative oveflow")
} }
t.TArrial = uint64(extra) extraI = -1 - extraI
// t.TSent (uint64) (uint64)
case "TSent":
maj, extra, err = cbg.CborReadHeader(br)
if err != nil {
return err
}
if maj != cbg.MajUnsignedInt {
return fmt.Errorf("wrong type for uint64 field")
}
t.TSent = uint64(extra)
default: default:
return fmt.Errorf("unknown struct field %d: '%s'", i, name) return fmt.Errorf("wrong type for int64 field: %d", maj)
} }
}
t.TArrial = int64(extraI)
}
// t.TSent (int64) (int64)
{
maj, extra, err := cbg.CborReadHeader(br)
var extraI int64
if err != nil {
return err
}
switch maj {
case cbg.MajUnsignedInt:
extraI = int64(extra)
if extraI < 0 {
return fmt.Errorf("int64 positive overflow")
}
case cbg.MajNegativeInt:
extraI = int64(extra)
if extraI < 0 {
return fmt.Errorf("int64 negative oveflow")
}
extraI = -1 - extraI
default:
return fmt.Errorf("wrong type for int64 field: %d", maj)
}
t.TSent = int64(extraI)
}
return nil return nil
} }

12
node/hello/hello.go
View File

@ -29,8 +29,8 @@ type HelloMessage struct {
GenesisHash cid.Cid GenesisHash cid.Cid
} }
type LatencyMessage struct { type LatencyMessage struct {
TArrial uint64 TArrial int64
TSent uint64 TSent int64
} }
type NewStreamFunc func(context.Context, peer.ID, ...protocol.ID) (inet.Stream, error) type NewStreamFunc func(context.Context, peer.ID, ...protocol.ID) (inet.Stream, error)
@ -81,8 +81,8 @@ func (hs *Service) HandleStream(s inet.Stream) {
sent := time.Now() sent := time.Now()
msg := &LatencyMessage{ msg := &LatencyMessage{
TArrial: uint64(arrived.UnixNano()), TArrial: arrived.UnixNano(),
TSent: uint64(sent.UnixNano()), TSent: sent.UnixNano(),
} }
if err := cborutil.WriteCborRPC(s, msg); err != nil { if err := cborutil.WriteCborRPC(s, msg); err != nil {
log.Debugf("error while responding to latency: %v", err) log.Debugf("error while responding to latency: %v", err)
@ -157,8 +157,8 @@ func (hs *Service) SayHello(ctx context.Context, pid peer.ID) error {
if err == nil { if err == nil {
if lmsg.TArrial != 0 && lmsg.TSent != 0 { if lmsg.TArrial != 0 && lmsg.TSent != 0 {
t1 := time.Unix(0, int64(lmsg.TArrial)) t1 := time.Unix(0, lmsg.TArrial)
t2 := time.Unix(0, int64(lmsg.TSent)) t2 := time.Unix(0, lmsg.TSent)
offset := t0.Sub(t1) + t3.Sub(t2) offset := t0.Sub(t1) + t3.Sub(t2)
offset /= 2 offset /= 2
log.Infow("time offset", "offset", offset.Seconds(), "peerid", pid.String()) log.Infow("time offset", "offset", offset.Seconds(), "peerid", pid.String())