certusone
/
tendermint
mirror of https://github.com/certusone/tendermint.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remote TypeByte()

This commit is contained in:
Jae Kwon 2015-04-14 15:57:16 -07:00
parent 37ddf3d09e
commit e5d34befde
12 changed files with 148 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
account/privkey.go
View File

@ -8,7 +8,6 @@ import (
// PrivKey is part of PrivAccount and state.PrivValidator.
type PrivKey interface {
TypeByte() byte
Sign(msg []byte) Signature
PubKey() PubKey
}
@ -21,7 +20,7 @@ const (
// for binary.readReflect
var _ = binary.RegisterInterface(
struct{ PrivKey }{},
binary.ConcreteType{PrivKeyEd25519{}},
binary.ConcreteType{PrivKeyEd25519{}, PrivKeyTypeEd25519},
)
//-------------------------------------
@ -29,8 +28,6 @@ var _ = binary.RegisterInterface(
// Implements PrivKey
type PrivKeyEd25519 []byte
func (privKey PrivKeyEd25519) TypeByte() byte { return PrivKeyTypeEd25519 }
func (privKey PrivKeyEd25519) Sign(msg []byte) Signature {
pubKey := privKey.PubKey().(PubKeyEd25519)
privKeyBytes := new([64]byte)

5
account/pubkey.go
View File

@ -9,7 +9,6 @@ import (
// PubKey is part of Account and Validator.
type PubKey interface {
TypeByte() byte
IsNil() bool
Address() []byte
VerifyBytes(msg []byte, sig Signature) bool
@ -23,7 +22,7 @@ const (
// for binary.readReflect
var _ = binary.RegisterInterface(
struct{ PubKey }{},
binary.ConcreteType{PubKeyEd25519{}},
binary.ConcreteType{PubKeyEd25519{}, PubKeyTypeEd25519},
)
//-------------------------------------
@ -31,8 +30,6 @@ var _ = binary.RegisterInterface(
// Implements PubKey
type PubKeyEd25519 []byte
func (pubKey PubKeyEd25519) TypeByte() byte { return PubKeyTypeEd25519 }
func (pubKey PubKeyEd25519) IsNil() bool { return false }
// TODO: Or should this just be BinaryRipemd160(key)? (The difference is the TypeByte.)

5
account/signature.go
View File

@ -9,7 +9,6 @@ import (
// Signature is a part of Txs and consensus Votes.
type Signature interface {
TypeByte() byte
}
// Types of Signature implementations
@ -20,7 +19,7 @@ const (
// for binary.readReflect
var _ = binary.RegisterInterface(
struct{ Signature }{},
binary.ConcreteType{SignatureEd25519{}},
binary.ConcreteType{SignatureEd25519{}, SignatureTypeEd25519},
)
//-------------------------------------
@ -28,8 +27,6 @@ var _ = binary.RegisterInterface(
// Implements Signature
type SignatureEd25519 []byte
func (sig SignatureEd25519) TypeByte() byte { return SignatureTypeEd25519 }
func (sig SignatureEd25519) IsNil() bool { return false }
func (sig SignatureEd25519) IsZero() bool { return len(sig) == 0 }

8
binary/README.md
View File

@ -1,3 +1,9 @@
### NOTICE
This documentation is out of date.
* 0x00 is reserved as a nil byte for RegisterInterface
* moved TypeByte() into RegisterInterface/ConcreteType
# `tendermint/binary`
The `binary` submodule encodes primary types and structs into bytes.
@ -127,4 +133,4 @@ is encoded or decoded directly:
WriteBinary(Dog{}, buf, n, err) // Writes GreeterTypeDog byte
dog_ := ReadBinary(Dog{}, buf, n, err) // Expects to read GreeterTypeDog byte
dog := dog_.(Dog) // ok if *err != nil, otherwise dog_ == nil.
```
```

172
binary/reflect.go
View File

@ -17,12 +17,11 @@ type TypeInfo struct {
// If Type is kind reflect.Interface, is registered
IsRegisteredInterface bool
ConcreteTypes map[byte]reflect.Type
ConcreteTypeBytes map[reflect.Type]byte
ByteToType map[byte]reflect.Type
TypeToByte map[reflect.Type]byte
// If Type is concrete
HasTypeByte bool
TypeByte byte
Byte byte
// If Type is kind reflect.Struct
Fields []StructFieldInfo
@ -47,12 +46,15 @@ func GetTypeFromStructDeclaration(o interface{}) reflect.Type {
return rt.Field(0).Type
}
// If o implements HasTypeByte, returns (true, typeByte)
func GetTypeByteFromStruct(o interface{}) (hasTypeByte bool, typeByte byte) {
if _, ok := o.(HasTypeByte); ok {
return true, o.(HasTypeByte).TypeByte()
} else {
return false, byte(0x00)
func SetByteForType(typeByte byte, rt reflect.Type) {
typeInfo := GetTypeInfo(rt)
if typeInfo.Byte != 0x00 && typeInfo.Byte != typeByte {
panic(Fmt("Type %v already registered with type byte %X", rt, typeByte))
}
typeInfo.Byte = typeByte
// If pointer, we need to set it for the concrete type as well.
if rt.Kind() == reflect.Ptr {
SetByteForType(typeByte, rt.Elem())
}
}
@ -65,14 +67,6 @@ const (
rfc2822 = "Mon Jan 02 15:04:05 -0700 2006"
)
// If a type implements TypeByte, the byte is included
// as the first byte for encoding and decoding.
// This is primarily used to encode interfaces types.
// The interface should be declared with RegisterInterface()
type HasTypeByte interface {
TypeByte() byte
}
// NOTE: do not access typeInfos directly, but call GetTypeInfo()
var typeInfosMtx sync.Mutex
var typeInfos = map[reflect.Type]*TypeInfo{}
@ -82,96 +76,52 @@ func GetTypeInfo(rt reflect.Type) *TypeInfo {
defer typeInfosMtx.Unlock()
info := typeInfos[rt]
if info == nil {
info = &TypeInfo{Type: rt}
RegisterType(info)
info = MakeTypeInfo(rt)
typeInfos[rt] = info
}
return info
}
// For use with the RegisterInterface declaration
type ConcreteType struct {
O interface{}
O interface{}
Byte byte
}
// Must use this to register an interface to properly decode the
// underlying concrete type.
func RegisterInterface(o interface{}, args ...interface{}) *TypeInfo {
func RegisterInterface(o interface{}, ctypes ...ConcreteType) *TypeInfo {
it := GetTypeFromStructDeclaration(o)
if it.Kind() != reflect.Interface {
panic("RegisterInterface expects an interface")
}
concreteTypes := make(map[byte]reflect.Type, 0)
concreteTypesReversed := make(map[reflect.Type]byte, 0)
for _, arg := range args {
switch arg.(type) {
case ConcreteType:
concreteTypeInfo := arg.(ConcreteType)
concreteType := reflect.TypeOf(concreteTypeInfo.O)
hasTypeByte, typeByte := GetTypeByteFromStruct(concreteTypeInfo.O)
//fmt.Println(Fmt("HasTypeByte: %v typeByte: %X type: %X", hasTypeByte, typeByte, concreteType))
if !hasTypeByte {
panic(Fmt("Expected concrete type %v to implement HasTypeByte", concreteType))
}
if typeByte == 0x00 {
panic(Fmt("TypeByte of 0x00 is reserved for nil (%v)", concreteType))
}
if concreteTypes[typeByte] != nil {
panic(Fmt("Duplicate TypeByte for type %v and %v", concreteType, concreteTypes[typeByte]))
}
concreteTypes[typeByte] = concreteType
concreteTypesReversed[concreteType] = typeByte
default:
panic(Fmt("Unexpected argument type %v", reflect.TypeOf(arg)))
toType := make(map[byte]reflect.Type, 0)
toByte := make(map[reflect.Type]byte, 0)
for _, ctype := range ctypes {
crt := reflect.TypeOf(ctype.O)
typeByte := ctype.Byte
SetByteForType(typeByte, crt)
if typeByte == 0x00 {
panic(Fmt("Byte of 0x00 is reserved for nil (%v)", ctype))
}
if toType[typeByte] != nil {
panic(Fmt("Duplicate Byte for type %v and %v", ctype, toType[typeByte]))
}
toType[typeByte] = crt
toByte[crt] = typeByte
}
typeInfo := &TypeInfo{
Type: it,
IsRegisteredInterface: true,
ConcreteTypes: concreteTypes,
ConcreteTypeBytes: concreteTypesReversed,
ByteToType: toType,
TypeToByte: toByte,
}
typeInfos[it] = typeInfo
return typeInfo
}
// Registers and possibly modifies the TypeInfo.
// NOTE: not goroutine safe, so only call upon program init.
func RegisterType(info *TypeInfo) *TypeInfo {
// Also register the dereferenced struct if info.Type is a pointer.
// Or, if info.Type is not a pointer, register the pointer.
var rt, ptrRt reflect.Type
if info.Type.Kind() == reflect.Ptr {
rt, ptrRt = info.Type.Elem(), info.Type
} else {
rt, ptrRt = info.Type, reflect.PtrTo(info.Type)
}
// Register the type info
typeInfos[rt] = info
typeInfos[ptrRt] = info
// See if the type implements HasTypeByte
if rt.Kind() != reflect.Interface &&
rt.Implements(reflect.TypeOf((*HasTypeByte)(nil)).Elem()) {
zero := reflect.Zero(rt)
typeByte := zero.Interface().(HasTypeByte).TypeByte()
if info.HasTypeByte && info.TypeByte != typeByte {
panic(Fmt("Type %v expected TypeByte of %X", rt, typeByte))
} else {
info.HasTypeByte = true
info.TypeByte = typeByte
}
} else if ptrRt.Implements(reflect.TypeOf((*HasTypeByte)(nil)).Elem()) {
zero := reflect.Zero(ptrRt)
typeByte := zero.Interface().(HasTypeByte).TypeByte()
if info.HasTypeByte && info.TypeByte != typeByte {
panic(Fmt("Type %v expected TypeByte of %X", ptrRt, typeByte))
} else {
info.HasTypeByte = true
info.TypeByte = typeByte
}
}
func MakeTypeInfo(rt reflect.Type) *TypeInfo {
info := &TypeInfo{Type: rt}
// If struct, register field name options
if rt.Kind() == reflect.Struct {
@ -218,7 +168,7 @@ func readReflect(rv reflect.Value, rt reflect.Type, r io.Reader, n *int64, err *
if typeByte == 0x00 {
return // nil
}
crt, ok := typeInfo.ConcreteTypes[typeByte]
crt, ok := typeInfo.ByteToType[typeByte]
if !ok {
*err = errors.New(Fmt("Unexpected type byte %X for type %v", typeByte, crt))
return
@ -247,17 +197,17 @@ func readReflect(rv reflect.Value, rt reflect.Type, r io.Reader, n *int64, err *
// Dereference pointer
rv, rt = rv.Elem(), rt.Elem()
typeInfo = GetTypeInfo(rt)
if typeInfo.HasTypeByte {
if typeInfo.Byte != 0x00 {
r = NewPrefixedReader([]byte{typeByte}, r)
}
// continue...
}
// Read TypeByte prefix
if typeInfo.HasTypeByte {
// Read Byte prefix
if typeInfo.Byte != 0x00 {
typeByte := ReadByte(r, n, err)
if typeByte != typeInfo.TypeByte {
*err = errors.New(Fmt("Expected TypeByte of %X but got %X", typeInfo.TypeByte, typeByte))
if typeByte != typeInfo.Byte {
*err = errors.New(Fmt("Expected Byte of %X but got %X", typeInfo.Byte, typeByte))
return
}
}
@ -384,7 +334,7 @@ func writeReflect(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64, err
if typeInfo.IsRegisteredInterface {
// See if the crt is registered.
// If so, we're more restrictive.
_, ok := typeInfo.ConcreteTypeBytes[crt]
_, ok := typeInfo.TypeToByte[crt]
if !ok {
switch crt.Kind() {
case reflect.Ptr:
@ -408,11 +358,12 @@ func writeReflect(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64, err
if rt.Kind() == reflect.Ptr {
// Dereference pointer
rv, rt = rv.Elem(), rt.Elem()
typeInfo = GetTypeInfo(rt)
if !rv.IsValid() {
WriteByte(0x00, w, n, err)
return
}
if !typeInfo.HasTypeByte {
if typeInfo.Byte == 0x00 {
WriteByte(0x01, w, n, err)
// continue...
} else {
@ -421,8 +372,8 @@ func writeReflect(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64, err
}
// Write type byte
if typeInfo.HasTypeByte {
WriteByte(typeInfo.TypeByte, w, n, err)
if typeInfo.Byte != 0x00 {
WriteByte(typeInfo.Byte, w, n, err)
}
// All other types
@ -507,14 +458,14 @@ func writeReflect(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64, err
//-----------------------------------------------------------------------------
func readTypeByteJSON(o interface{}) (typeByte byte, rest interface{}, err error) {
func readByteJSON(o interface{}) (typeByte byte, rest interface{}, err error) {
oSlice, ok := o.([]interface{})
if !ok {
err = errors.New(Fmt("Expected type [TypeByte,?] but got type %v", reflect.TypeOf(o)))
err = errors.New(Fmt("Expected type [Byte,?] but got type %v", reflect.TypeOf(o)))
return
}
if len(oSlice) != 2 {
err = errors.New(Fmt("Expected [TypeByte,?] len 2 but got len %v", len(oSlice)))
err = errors.New(Fmt("Expected [Byte,?] len 2 but got len %v", len(oSlice)))
return
}
typeByte_, ok := oSlice[0].(float64)
@ -537,14 +488,14 @@ func readReflectJSON(rv reflect.Value, rt reflect.Type, o interface{}, err *erro
if o == nil {
return // nil
}
typeByte, _, err_ := readTypeByteJSON(o)
typeByte, _, err_ := readByteJSON(o)
if err_ != nil {
*err = err_
return
}
crt, ok := typeInfo.ConcreteTypes[typeByte]
crt, ok := typeInfo.ByteToType[typeByte]
if !ok {
*err = errors.New(Fmt("TypeByte %X not registered for interface %v", typeByte, rt))
*err = errors.New(Fmt("Byte %X not registered for interface %v", typeByte, rt))
return
}
crv := reflect.New(crt).Elem()
@ -565,18 +516,19 @@ func readReflectJSON(rv reflect.Value, rt reflect.Type, o interface{}, err *erro
}
// Dereference pointer
rv, rt = rv.Elem(), rt.Elem()
typeInfo = GetTypeInfo(rt)
// continue...
}
// Read TypeByte prefix
if typeInfo.HasTypeByte {
typeByte, rest, err_ := readTypeByteJSON(o)
// Read Byte prefix
if typeInfo.Byte != 0x00 {
typeByte, rest, err_ := readByteJSON(o)
if err_ != nil {
*err = err_
return
}
if typeByte != typeInfo.TypeByte {
*err = errors.New(Fmt("Expected TypeByte of %X but got %X", typeInfo.TypeByte, byte(typeByte)))
if typeByte != typeInfo.Byte {
*err = errors.New(Fmt("Expected Byte of %X but got %X", typeInfo.Byte, byte(typeByte)))
return
}
o = rest
@ -697,6 +649,7 @@ func readReflectJSON(rv reflect.Value, rt reflect.Type, o interface{}, err *erro
}
func writeReflectJSON(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64, err *error) {
log.Debug(Fmt("writeReflectJSON(%v, %v, %v, %v, %v)", rv, rt, w, n, err))
// Get typeInfo
typeInfo := GetTypeInfo(rt)
@ -712,7 +665,7 @@ func writeReflectJSON(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64,
if typeInfo.IsRegisteredInterface {
// See if the crt is registered.
// If so, we're more restrictive.
_, ok := typeInfo.ConcreteTypeBytes[crt]
_, ok := typeInfo.TypeToByte[crt]
if !ok {
switch crt.Kind() {
case reflect.Ptr:
@ -736,6 +689,7 @@ func writeReflectJSON(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64,
if rt.Kind() == reflect.Ptr {
// Dereference pointer
rv, rt = rv.Elem(), rt.Elem()
typeInfo = GetTypeInfo(rt)
if !rv.IsValid() {
WriteTo([]byte("null"), w, n, err)
return
@ -743,9 +697,9 @@ func writeReflectJSON(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64,
// continue...
}
// Write TypeByte
if typeInfo.HasTypeByte {
WriteTo([]byte(Fmt("[%v,", typeInfo.TypeByte)), w, n, err)
// Write Byte
if typeInfo.Byte != 0x00 {
WriteTo([]byte(Fmt("[%v,", typeInfo.Byte)), w, n, err)
defer WriteTo([]byte("]"), w, n, err)
}

16
binary/reflect_test.go
View File

@ -30,33 +30,25 @@ type Cat struct {
SimpleStruct
}
func (cat Cat) TypeByte() byte { return AnimalTypeCat }
// Implements Animal
type Dog struct {
SimpleStruct
}
func (dog Dog) TypeByte() byte { return AnimalTypeDog }
// Implements Animal
type Snake []byte
func (snake Snake) TypeByte() byte { return AnimalTypeSnake }
// Implements Animal
type Viper struct {
Bytes []byte
}
func (viper *Viper) TypeByte() byte { return AnimalTypeViper }
var _ = RegisterInterface(
struct{ Animal }{},
ConcreteType{Cat{}},
ConcreteType{Dog{}},
ConcreteType{Snake{}},
ConcreteType{&Viper{}},
ConcreteType{Cat{}, AnimalTypeCat},
ConcreteType{Dog{}, AnimalTypeDog},
ConcreteType{Snake{}, AnimalTypeSnake},
ConcreteType{&Viper{}, AnimalTypeViper},
)
func TestAnimalInterface(t *testing.T) {

39
blockchain/reactor.go
View File

@ -116,15 +116,15 @@ func (bcR *BlockchainReactor) RemovePeer(peer *p2p.Peer, reason interface{}) {
// Implements Reactor
func (bcR *BlockchainReactor) Receive(chId byte, src *p2p.Peer, msgBytes []byte) {
_, msg_, err := DecodeMessage(msgBytes)
_, msg, err := DecodeMessage(msgBytes)
if err != nil {
log.Warn("Error decoding message", "error", err)
return
}
log.Info("Received message", "msg", msg_)
log.Info("Received message", "msg", msg)
switch msg := msg_.(type) {
switch msg := msg.(type) {
case bcBlockRequestMessage:
// Got a request for a block. Respond with block if we have it.
block := bcR.store.LoadBlock(msg.Height)
@ -251,28 +251,25 @@ func (bcR *BlockchainReactor) SetEventSwitch(evsw *events.EventSwitch) {
// Messages
const (
msgTypeUnknown = byte(0x00)
msgTypeBlockRequest = byte(0x10)
msgTypeBlockResponse = byte(0x11)
msgTypePeerStatus = byte(0x20)
)
// TODO: check for unnecessary extra bytes at the end.
func DecodeMessage(bz []byte) (msgType byte, msg interface{}, err error) {
n := new(int64)
type BlockchainMessage interface{}
var _ = binary.RegisterInterface(
struct{ BlockchainMessage }{},
binary.ConcreteType{bcBlockRequestMessage{}, msgTypeBlockRequest},
binary.ConcreteType{bcBlockResponseMessage{}, msgTypeBlockResponse},
binary.ConcreteType{bcPeerStatusMessage{}, msgTypePeerStatus},
)
func DecodeMessage(bz []byte) (msgType byte, msg BlockchainMessage, err error) {
msgType = bz[0]
n := new(int64)
r := bytes.NewReader(bz)
switch msgType {
case msgTypeBlockRequest:
msg = binary.ReadBinary(bcBlockRequestMessage{}, r, n, &err)
case msgTypeBlockResponse:
msg = binary.ReadBinary(bcBlockResponseMessage{}, r, n, &err)
case msgTypePeerStatus:
msg = binary.ReadBinary(bcPeerStatusMessage{}, r, n, &err)
default:
log.Warn(Fmt("Ignoring unknown message %X", bz))
msg = nil
}
msg = binary.ReadBinary(&msg, r, n, &err)
return
}
@ -282,8 +279,6 @@ type bcBlockRequestMessage struct {
Height uint
}
func (m bcBlockRequestMessage) TypeByte() byte { return msgTypeBlockRequest }
func (m bcBlockRequestMessage) String() string {
return fmt.Sprintf("[bcBlockRequestMessage %v]", m.Height)
}
@ -294,8 +289,6 @@ type bcBlockResponseMessage struct {
Block *types.Block
}
func (m bcBlockResponseMessage) TypeByte() byte { return msgTypeBlockResponse }
func (m bcBlockResponseMessage) String() string {
return fmt.Sprintf("[bcBlockResponseMessage %v]", m.Block.Height)
}
@ -306,8 +299,6 @@ type bcPeerStatusMessage struct {
Height uint
}
func (m bcPeerStatusMessage) TypeByte() byte { return msgTypePeerStatus }
func (m bcPeerStatusMessage) String() string {
return fmt.Sprintf("[bcPeerStatusMessage %v]", m.Height)
}

29
cmd/barak/types/command.go
View File

@ -17,29 +17,22 @@ type NoncedCommand struct {
type Command interface{}
const (
commandTypeRunProcess = 0x01
commandTypeStopProcess = 0x02
commandTypeListProcesses = 0x03
commandTypeServeFile = 0x04
)
// for binary.readReflect
var _ = binary.RegisterInterface(
struct{ Command }{},
binary.ConcreteType{CommandRunProcess{}},
binary.ConcreteType{CommandStopProcess{}},
binary.ConcreteType{CommandListProcesses{}},
binary.ConcreteType{CommandServeFile{}},
binary.ConcreteType{CommandRunProcess{}, commandTypeRunProcess},
binary.ConcreteType{CommandStopProcess{}, commandTypeStopProcess},
binary.ConcreteType{CommandListProcesses{}, commandTypeListProcesses},
binary.ConcreteType{CommandServeFile{}, commandTypeServeFile},
)
const (
typeByteRunProcess = 0x01
typeByteStopProcess = 0x02
typeByteListProcesses = 0x03
typeByteServeFile = 0x04
)
// TODO: This is actually not cleaner than a method call.
// In fact, this is stupid.
func (_ CommandRunProcess) TypeByte() byte { return typeByteRunProcess }
func (_ CommandStopProcess) TypeByte() byte { return typeByteStopProcess }
func (_ CommandListProcesses) TypeByte() byte { return typeByteListProcesses }
func (_ CommandServeFile) TypeByte() byte { return typeByteServeFile }
type CommandRunProcess struct {
Wait bool
Label string

49
consensus/reactor.go
View File

@ -763,31 +763,24 @@ const (
msgTypeHasVote = byte(0x14)
)
type ConsensusMessage interface{}
var _ = binary.RegisterInterface(
struct{ ConsensusMessage }{},
binary.ConcreteType{NewRoundStepMessage{}, msgTypeNewRoundStep},
binary.ConcreteType{CommitStepMessage{}, msgTypeCommitStep},
binary.ConcreteType{ProposalMessage{}, msgTypeProposal},
binary.ConcreteType{PartMessage{}, msgTypePart},
binary.ConcreteType{VoteMessage{}, msgTypeVote},
binary.ConcreteType{HasVoteMessage{}, msgTypeHasVote},
)
// TODO: check for unnecessary extra bytes at the end.
func DecodeMessage(bz []byte) (msgType byte, msg interface{}, err error) {
n := new(int64)
// log.Debug(Fmt("decoding msg bytes: %X", bz))
func DecodeMessage(bz []byte) (msgType byte, msg ConsensusMessage, err error) {
msgType = bz[0]
n := new(int64)
r := bytes.NewReader(bz)
switch msgType {
// Messages for communicating state changes
case msgTypeNewRoundStep:
msg = binary.ReadBinary(&NewRoundStepMessage{}, r, n, &err)
case msgTypeCommitStep:
msg = binary.ReadBinary(&CommitStepMessage{}, r, n, &err)
// Messages of data
case msgTypeProposal:
msg = binary.ReadBinary(&ProposalMessage{}, r, n, &err)
case msgTypePart:
msg = binary.ReadBinary(&PartMessage{}, r, n, &err)
case msgTypeVote:
msg = binary.ReadBinary(&VoteMessage{}, r, n, &err)
case msgTypeHasVote:
msg = binary.ReadBinary(&HasVoteMessage{}, r, n, &err)
default:
log.Warn(Fmt("Ignoring unknown message %X", bz))
msg = nil
}
msg = binary.ReadBinary(&msg, r, n, &err)
return
}
@ -800,8 +793,6 @@ type NewRoundStepMessage struct {
SecondsSinceStartTime uint
}
func (m *NewRoundStepMessage) TypeByte() byte { return msgTypeNewRoundStep }
func (m *NewRoundStepMessage) String() string {
return fmt.Sprintf("[NewRoundStep H:%v R:%v S:%v]", m.Height, m.Round, m.Step)
}
@ -814,8 +805,6 @@ type CommitStepMessage struct {
BlockBitArray BitArray
}
func (m *CommitStepMessage) TypeByte() byte { return msgTypeCommitStep }
func (m *CommitStepMessage) String() string {
return fmt.Sprintf("[CommitStep H:%v BP:%v BA:%v]", m.Height, m.BlockParts, m.BlockBitArray)
}
@ -826,8 +815,6 @@ type ProposalMessage struct {
Proposal *Proposal
}
func (m *ProposalMessage) TypeByte() byte { return msgTypeProposal }
func (m *ProposalMessage) String() string {
return fmt.Sprintf("[Proposal %v]", m.Proposal)
}
@ -846,8 +833,6 @@ type PartMessage struct {
Part *types.Part
}
func (m *PartMessage) TypeByte() byte { return msgTypePart }
func (m *PartMessage) String() string {
return fmt.Sprintf("[Part H:%v R:%v T:%X P:%v]", m.Height, m.Round, m.Type, m.Part)
}
@ -859,8 +844,6 @@ type VoteMessage struct {
Vote *types.Vote
}
func (m *VoteMessage) TypeByte() byte { return msgTypeVote }
func (m *VoteMessage) String() string {
return fmt.Sprintf("[Vote VI:%v V:%v]", m.ValidatorIndex, m.Vote)
}
@ -874,8 +857,6 @@ type HasVoteMessage struct {
Index uint
}
func (m *HasVoteMessage) TypeByte() byte { return msgTypeHasVote }
func (m *HasVoteMessage) String() string {
return fmt.Sprintf("[HasVote %v/%v T:%X]", m.Height, m.Round, m.Type)
}

26
mempool/reactor.go
View File

@ -6,7 +6,6 @@ import (
"sync/atomic"
"github.com/tendermint/tendermint/binary"
. "github.com/tendermint/tendermint/common"
"github.com/tendermint/tendermint/events"
"github.com/tendermint/tendermint/p2p"
"github.com/tendermint/tendermint/types"
@ -123,22 +122,21 @@ func (memR *MempoolReactor) SetEventSwitch(evsw *events.EventSwitch) {
// Messages
const (
msgTypeUnknown = byte(0x00)
msgTypeTx = byte(0x01)
msgTypeTx = byte(0x01)
)
// TODO: check for unnecessary extra bytes at the end.
func DecodeMessage(bz []byte) (msgType byte, msg interface{}, err error) {
n := new(int64)
type MempoolMessage interface{}
var _ = binary.RegisterInterface(
struct{ MempoolMessage }{},
binary.ConcreteType{TxMessage{}, msgTypeTx},
)
func DecodeMessage(bz []byte) (msgType byte, msg MempoolMessage, err error) {
msgType = bz[0]
n := new(int64)
r := bytes.NewReader(bz)
switch msgType {
case msgTypeTx:
msg = binary.ReadBinary(&TxMessage{}, r, n, &err)
default:
log.Warn(Fmt("Ignoring unknown message %X", bz))
msg = nil
}
msg = binary.ReadBinary(&msg, r, n, &err)
return
}
@ -148,8 +146,6 @@ type TxMessage struct {
Tx types.Tx
}
func (m *TxMessage) TypeByte() byte { return msgTypeTx }
func (m *TxMessage) String() string {
return fmt.Sprintf("[TxMessage %v]", m.Tx)
}

36
p2p/pex_reactor.go
View File

@ -92,7 +92,7 @@ func (pexR *PEXReactor) RemovePeer(peer *Peer, reason interface{}) {
func (pexR *PEXReactor) Receive(chId byte, src *Peer, msgBytes []byte) {
// decode message
msg, err := DecodeMessage(msgBytes)
_, msg, err := DecodeMessage(msgBytes)
if err != nil {
log.Warn("Error decoding message", "error", err)
return
@ -219,29 +219,25 @@ func (pexR *PEXReactor) SetEventSwitch(evsw *events.EventSwitch) {
// Messages
const (
msgTypeUnknown = byte(0x00)
msgTypeRequest = byte(0x01)
msgTypeAddrs = byte(0x02)
msgTypeHandshake = byte(0x03)
)
// TODO: check for unnecessary extra bytes at the end.
func DecodeMessage(bz []byte) (msg interface{}, err error) {
type PexMessage interface{}
var _ = binary.RegisterInterface(
struct{ PexMessage }{},
binary.ConcreteType{pexHandshakeMessage{}, msgTypeHandshake},
binary.ConcreteType{pexRequestMessage{}, msgTypeRequest},
binary.ConcreteType{pexAddrsMessage{}, msgTypeAddrs},
)
func DecodeMessage(bz []byte) (msgType byte, msg PexMessage, err error) {
msgType = bz[0]
n := new(int64)
msgType := bz[0]
r := bytes.NewReader(bz)
// log.Debug(Fmt("decoding msg bytes: %X", bz))
switch msgType {
case msgTypeHandshake:
msg = binary.ReadBinary(&pexHandshakeMessage{}, r, n, &err)
case msgTypeRequest:
msg = &pexRequestMessage{}
case msgTypeAddrs:
msg = binary.ReadBinary(&pexAddrsMessage{}, r, n, &err)
default:
log.Warn(Fmt("Ignoring unknown message %X", bz))
msg = nil
}
msg = binary.ReadBinary(&msg, r, n, &err)
return
}
@ -252,8 +248,6 @@ type pexHandshakeMessage struct {
Network string
}
func (m *pexHandshakeMessage) TypeByte() byte { return msgTypeHandshake }
func (m *pexHandshakeMessage) String() string {
return "[pexHandshake]"
}
@ -264,8 +258,6 @@ A pexRequestMessage requests additional peer addresses.
type pexRequestMessage struct {
}
func (m *pexRequestMessage) TypeByte() byte { return msgTypeRequest }
func (m *pexRequestMessage) String() string {
return "[pexRequest]"
}
@ -277,8 +269,6 @@ type pexAddrsMessage struct {
Addrs []*NetAddress
}
func (m *pexAddrsMessage) TypeByte() byte { return msgTypeAddrs }
func (m *pexAddrsMessage) String() string {
return fmt.Sprintf("[pexAddrs %v]", m.Addrs)
}

24
types/tx.go
View File

@ -61,12 +61,12 @@ const (
// for binary.readReflect
var _ = binary.RegisterInterface(
struct{ Tx }{},
binary.ConcreteType{&SendTx{}},
binary.ConcreteType{&CallTx{}},
binary.ConcreteType{&BondTx{}},
binary.ConcreteType{&UnbondTx{}},
binary.ConcreteType{&RebondTx{}},
binary.ConcreteType{&DupeoutTx{}},
binary.ConcreteType{&SendTx{}, TxTypeSend},
binary.ConcreteType{&CallTx{}, TxTypeCall},
binary.ConcreteType{&BondTx{}, TxTypeBond},
binary.ConcreteType{&UnbondTx{}, TxTypeUnbond},
binary.ConcreteType{&RebondTx{}, TxTypeRebond},
binary.ConcreteType{&DupeoutTx{}, TxTypeDupeout},
)
//-----------------------------------------------------------------------------
@ -132,8 +132,6 @@ type SendTx struct {
Outputs []*TxOutput
}
func (tx *SendTx) TypeByte() byte { return TxTypeSend }
func (tx *SendTx) WriteSignBytes(w io.Writer, n *int64, err *error) {
binary.WriteUvarint(uint(len(tx.Inputs)), w, n, err)
for _, in := range tx.Inputs {
@ -159,8 +157,6 @@ type CallTx struct {
Data []byte
}
func (tx *CallTx) TypeByte() byte { return TxTypeCall }
func (tx *CallTx) WriteSignBytes(w io.Writer, n *int64, err *error) {
tx.Input.WriteSignBytes(w, n, err)
binary.WriteByteSlice(tx.Address, w, n, err)
@ -181,8 +177,6 @@ type BondTx struct {
UnbondTo []*TxOutput
}
func (tx *BondTx) TypeByte() byte { return TxTypeBond }
func (tx *BondTx) WriteSignBytes(w io.Writer, n *int64, err *error) {
binary.WriteBinary(tx.PubKey, w, n, err)
binary.WriteUvarint(uint(len(tx.Inputs)), w, n, err)
@ -207,8 +201,6 @@ type UnbondTx struct {
Signature account.SignatureEd25519
}
func (tx *UnbondTx) TypeByte() byte { return TxTypeUnbond }
func (tx *UnbondTx) WriteSignBytes(w io.Writer, n *int64, err *error) {
binary.WriteByteSlice(tx.Address, w, n, err)
binary.WriteUvarint(tx.Height, w, n, err)
@ -226,8 +218,6 @@ type RebondTx struct {
Signature account.SignatureEd25519
}
func (tx *RebondTx) TypeByte() byte { return TxTypeRebond }
func (tx *RebondTx) WriteSignBytes(w io.Writer, n *int64, err *error) {
binary.WriteByteSlice(tx.Address, w, n, err)
binary.WriteUvarint(tx.Height, w, n, err)
@ -245,8 +235,6 @@ type DupeoutTx struct {
VoteB Vote
}
func (tx *DupeoutTx) TypeByte() byte { return TxTypeDupeout }
func (tx *DupeoutTx) WriteSignBytes(w io.Writer, n *int64, err *error) {
panic("DupeoutTx has no sign bytes")
}