From 34f73a43c28348491aba2572211bf949a44458d4 Mon Sep 17 00:00:00 2001 From: Kenta Iwasaki Date: Thu, 14 Feb 2019 00:24:04 +0800 Subject: [PATCH] codecov: updated ignore list msg, init, empty, opcode, peer: split up msg.go into separate files examples/e2e: increase num messages for each node --- .codecov.yml | 14 +++-- empty.go | 15 +++++ examples/e2e/e2e_test.go | 12 ++-- init.go | 2 + msg.go | 131 --------------------------------------- msg_test.go | 76 ----------------------- opcode.go | 120 +++++++++++++++++++++++++++++++++++ opcode_test.go | 26 ++++++++ peer_test.go | 57 +++++++++++++++++ 9 files changed, 234 insertions(+), 219 deletions(-) create mode 100644 empty.go create mode 100644 opcode.go create mode 100644 opcode_test.go create mode 100644 peer_test.go diff --git a/.codecov.yml b/.codecov.yml index aa721c89..9764fe13 100644 --- a/.codecov.yml +++ b/.codecov.yml @@ -5,10 +5,12 @@ codecov: ignore: - "./examples" - - "**/mocks" - - "**/*.pb.go" - - "scripts.go" - - "./crypto/ed25519/internal/edwards25519" + - "./crypto/suite.go" + - "./params.go" + - "./init.go" + - "./empty.go" + - "./callbacks.go" + - "./identity/manager.go" comment: false @@ -18,8 +20,8 @@ coverage: status: project: default: - threshold: 20% - if_not_found: success + threshold: 20% + if_not_found: success patch: default: enabled: no diff --git a/empty.go b/empty.go new file mode 100644 index 00000000..36f5956f --- /dev/null +++ b/empty.go @@ -0,0 +1,15 @@ +package noise + +import "github.com/perlin-network/noise/payload" + +var _ Message = (*EmptyMessage)(nil) + +type EmptyMessage struct{} + +func (EmptyMessage) Read(reader payload.Reader) (Message, error) { + return EmptyMessage{}, nil +} + +func (EmptyMessage) Write() []byte { + return nil +} diff --git a/examples/e2e/e2e_test.go b/examples/e2e/e2e_test.go index 001b28c0..52975c76 100644 --- a/examples/e2e/e2e_test.go +++ b/examples/e2e/e2e_test.go @@ -20,10 +20,10 @@ import ( ) var ( - _ noise.Message = (*testMessage)(nil) - startPort = 4000 - numNodes = 10 - numTxEach = 100 + _ noise.Message = (*testMessage)(nil) + startPort = 4000 + numNodes = 16 + numMessagesEach = 1000 ) type testMessage struct { @@ -33,7 +33,7 @@ type testMessage struct { func (testMessage) Read(reader payload.Reader) (noise.Message, error) { text, err := reader.ReadString() if err != nil { - return nil, errors.Wrap(err, "failed to read test msg") + return nil, errors.Wrap(err, "failed to read test message") } return testMessage{text: text}, nil @@ -143,7 +143,7 @@ func Run(startPort int, numNodes int, numTxEach int) error { } func TestRun(t *testing.T) { - assert.Nil(t, Run(startPort, numNodes, numTxEach)) + assert.Nil(t, Run(startPort, numNodes, numMessagesEach)) t.Log("Done") } diff --git a/init.go b/init.go index 55030e72..ab452026 100644 --- a/init.go +++ b/init.go @@ -3,5 +3,7 @@ package noise import "go.dedis.ch/kyber/v3/suites" func init() { + resetOpcodes() + suites.RequireConstantTime() } diff --git a/msg.go b/msg.go index 5eaa4024..aa2a3e9a 100644 --- a/msg.go +++ b/msg.go @@ -2,129 +2,10 @@ package noise import ( "bytes" - "fmt" - "github.com/perlin-network/noise/log" "github.com/perlin-network/noise/payload" "github.com/pkg/errors" - "reflect" - "sync" ) -type Opcode byte - -const ( - OpcodeNil Opcode = 0 -) - -var ( - opcodes map[Opcode]Message - messages map[reflect.Type]Opcode - - opcodesMutex sync.Mutex -) - -func init() { - resetOpcodes() -} - -// Bytes returns this opcodes' byte representation. -func (o Opcode) Bytes() (buf [1]byte) { - buf[0] = byte(o) - return -} - -// NextAvailableOpcode returns the next available unregistered message opcode -// registered to Noise. -func NextAvailableOpcode() Opcode { - opcodesMutex.Lock() - defer opcodesMutex.Unlock() - - return Opcode(len(opcodes)) -} - -// DebugOpcodes prints out all opcodes registered to Noise thus far. -func DebugOpcodes() { - opcodesMutex.Lock() - defer opcodesMutex.Unlock() - - log.Debug().Msg("Here are all opcodes registered so far.") - - for i := 0; i < len(opcodes); i++ { - fmt.Printf("Opcode %d is registered to: %s\n", i, reflect.TypeOf(opcodes[Opcode(i)]).String()) - } -} - -// MessageFromOpcode returns an empty message representation associated to a registered -// message opcode. -// -// It errors if the specified message opcode is not registered to Noise. -func MessageFromOpcode(opcode Opcode) (Message, error) { - opcodesMutex.Lock() - defer opcodesMutex.Unlock() - - typ, exists := opcodes[Opcode(opcode)] - if !exists { - return nil, errors.Errorf("there is no message type registered to opcode %d", opcode) - } - - message, ok := reflect.New(reflect.TypeOf(typ)).Elem().Interface().(Message) - if !ok { - return nil, errors.Errorf("invalid message type associated to opcode %d", opcode) - } - - return message, nil -} - -// OpcodeFromMessage uses reflection to extract and return the opcode associated to a message -// value type. -// -// It errors if the specified message value type is not registered to Noise. -func OpcodeFromMessage(msg Message) (Opcode, error) { - opcodesMutex.Lock() - defer opcodesMutex.Unlock() - - typ := reflect.TypeOf(msg) - if typ.Kind() == reflect.Ptr { - typ = typ.Elem() - } - - opcode, exists := messages[typ] - if !exists { - return OpcodeNil, errors.Errorf("there is no opcode registered for message type %v", typ) - } - - return opcode, nil -} - -func RegisterMessage(o Opcode, m interface{}) Opcode { - typ := reflect.TypeOf(m).Elem() - - opcodesMutex.Lock() - defer opcodesMutex.Unlock() - - if opcode, registered := messages[typ]; registered { - return opcode - } - - opcodes[o] = reflect.New(typ).Elem().Interface().(Message) - messages[typ] = o - - return o -} - -func resetOpcodes() { - opcodesMutex.Lock() - defer opcodesMutex.Unlock() - - opcodes = map[Opcode]Message{ - OpcodeNil: reflect.New(reflect.TypeOf((*EmptyMessage)(nil)).Elem()).Elem().Interface().(Message), - } - - messages = map[reflect.Type]Opcode{ - reflect.TypeOf((*EmptyMessage)(nil)).Elem(): OpcodeNil, - } -} - // To have Noise send/receive messages of a given type, said type must implement the // following Message interface. // @@ -243,15 +124,3 @@ func (p *Peer) DecodeMessage(buf []byte) (Opcode, Message, error) { return Opcode(opcode), message, nil } - -var _ Message = (*EmptyMessage)(nil) - -type EmptyMessage struct{} - -func (EmptyMessage) Read(reader payload.Reader) (Message, error) { - return EmptyMessage{}, nil -} - -func (EmptyMessage) Write() []byte { - return nil -} diff --git a/msg_test.go b/msg_test.go index 9cae460a..5b190a39 100644 --- a/msg_test.go +++ b/msg_test.go @@ -1,77 +1 @@ package noise - -import ( - "github.com/perlin-network/noise/payload" - "github.com/pkg/errors" - "github.com/stretchr/testify/assert" - "testing" -) - -type testMsg struct { - text string -} - -func (testMsg) Read(reader payload.Reader) (Message, error) { - text, err := reader.ReadString() - if err != nil { - return nil, errors.Wrap(err, "failed to read chat msg") - } - - return testMsg{text: text}, nil -} - -func (m testMsg) Write() []byte { - return payload.NewWriter(nil).WriteString(m.text).Bytes() -} - -func TestNextAvailableOpcode(t *testing.T) { - resetOpcodes() - - // opcode 0 should be an empty message - msg, err := MessageFromOpcode(Opcode(0)) - assert.Nil(t, err) - assert.Equal(t, EmptyMessage{}, msg) - - // an unset opcode should be an error - _, err = MessageFromOpcode(Opcode(1)) - assert.NotNil(t, err) - - RegisterMessage(Opcode(1), (*testMsg)(nil)) - - // an opcode should still exist after the loop - msg, err = MessageFromOpcode(Opcode(1)) - assert.Nil(t, err) - assert.Equal(t, testMsg{}, msg) -} - -func TestEncodeMessage(t *testing.T) { - resetOpcodes() - o := RegisterMessage(Opcode(123), (*testMsg)(nil)) - - msg := testMsg{ - text: "hello", - } - - p := newPeer(nil, nil) - - bytes, err := p.EncodeMessage(msg) - assert.Nil(t, err) - assert.Equal(t, append([]byte{byte(o)}, msg.Write()...), bytes) -} - -func TestDecodeMessage(t *testing.T) { - resetOpcodes() - o := RegisterMessage(Opcode(45), (*testMsg)(nil)) - - msg := testMsg{ - text: "world", - } - assert.Equal(t, o, RegisterMessage(o, (*testMsg)(nil))) - - p := newPeer(nil, nil) - - resultO, resultM, err := p.DecodeMessage(append([]byte{byte(o)}, msg.Write()...)) - assert.Nil(t, err) - assert.Equal(t, o, resultO) - assert.Equal(t, msg, resultM) -} diff --git a/opcode.go b/opcode.go new file mode 100644 index 00000000..9f24153b --- /dev/null +++ b/opcode.go @@ -0,0 +1,120 @@ +package noise + +import ( + "fmt" + "github.com/perlin-network/noise/log" + "github.com/pkg/errors" + "reflect" + "sync" +) + +type Opcode byte + +const ( + OpcodeNil Opcode = 0 +) + +var ( + opcodes map[Opcode]Message + messages map[reflect.Type]Opcode + + opcodesMutex sync.Mutex +) + +// Bytes returns this opcodes' byte representation. +func (o Opcode) Bytes() (buf [1]byte) { + buf[0] = byte(o) + return +} + +// NextAvailableOpcode returns the next available unregistered message opcode +// registered to Noise. +func NextAvailableOpcode() Opcode { + opcodesMutex.Lock() + defer opcodesMutex.Unlock() + + return Opcode(len(opcodes)) +} + +// DebugOpcodes prints out all opcodes registered to Noise thus far. +func DebugOpcodes() { + opcodesMutex.Lock() + defer opcodesMutex.Unlock() + + log.Debug().Msg("Here are all opcodes registered so far.") + + for i := 0; i < len(opcodes); i++ { + fmt.Printf("Opcode %d is registered to: %s\n", i, reflect.TypeOf(opcodes[Opcode(i)]).String()) + } +} + +// MessageFromOpcode returns an empty message representation associated to a registered +// message opcode. +// +// It errors if the specified message opcode is not registered to Noise. +func MessageFromOpcode(opcode Opcode) (Message, error) { + opcodesMutex.Lock() + defer opcodesMutex.Unlock() + + typ, exists := opcodes[Opcode(opcode)] + if !exists { + return nil, errors.Errorf("there is no message type registered to opcode %d", opcode) + } + + message, ok := reflect.New(reflect.TypeOf(typ)).Elem().Interface().(Message) + if !ok { + return nil, errors.Errorf("invalid message type associated to opcode %d", opcode) + } + + return message, nil +} + +// OpcodeFromMessage uses reflection to extract and return the opcode associated to a message +// value type. +// +// It errors if the specified message value type is not registered to Noise. +func OpcodeFromMessage(msg Message) (Opcode, error) { + opcodesMutex.Lock() + defer opcodesMutex.Unlock() + + typ := reflect.TypeOf(msg) + if typ.Kind() == reflect.Ptr { + typ = typ.Elem() + } + + opcode, exists := messages[typ] + if !exists { + return OpcodeNil, errors.Errorf("there is no opcode registered for message type %v", typ) + } + + return opcode, nil +} + +func RegisterMessage(o Opcode, m interface{}) Opcode { + typ := reflect.TypeOf(m).Elem() + + opcodesMutex.Lock() + defer opcodesMutex.Unlock() + + if opcode, registered := messages[typ]; registered { + return opcode + } + + opcodes[o] = reflect.New(typ).Elem().Interface().(Message) + messages[typ] = o + + return o +} + +func resetOpcodes() { + opcodesMutex.Lock() + defer opcodesMutex.Unlock() + + opcodes = map[Opcode]Message{ + OpcodeNil: reflect.New(reflect.TypeOf((*EmptyMessage)(nil)).Elem()).Elem().Interface().(Message), + } + + messages = map[reflect.Type]Opcode{ + reflect.TypeOf((*EmptyMessage)(nil)).Elem(): OpcodeNil, + } +} diff --git a/opcode_test.go b/opcode_test.go new file mode 100644 index 00000000..6ceed63d --- /dev/null +++ b/opcode_test.go @@ -0,0 +1,26 @@ +package noise + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestNextAvailableOpcode(t *testing.T) { + resetOpcodes() + + // opcode 0 should be an empty message + msg, err := MessageFromOpcode(Opcode(0)) + assert.Nil(t, err) + assert.Equal(t, EmptyMessage{}, msg) + + // an unset opcode should be an error + _, err = MessageFromOpcode(Opcode(1)) + assert.NotNil(t, err) + + RegisterMessage(Opcode(1), (*testMsg)(nil)) + + // an opcode should still exist after the loop + msg, err = MessageFromOpcode(Opcode(1)) + assert.Nil(t, err) + assert.Equal(t, testMsg{}, msg) +} diff --git a/peer_test.go b/peer_test.go new file mode 100644 index 00000000..3e7ff246 --- /dev/null +++ b/peer_test.go @@ -0,0 +1,57 @@ +package noise + +import ( + "github.com/perlin-network/noise/payload" + "github.com/pkg/errors" + "github.com/stretchr/testify/assert" + "testing" +) + +type testMsg struct { + text string +} + +func (testMsg) Read(reader payload.Reader) (Message, error) { + text, err := reader.ReadString() + if err != nil { + return nil, errors.Wrap(err, "failed to read test message") + } + + return testMsg{text: text}, nil +} + +func (m testMsg) Write() []byte { + return payload.NewWriter(nil).WriteString(m.text).Bytes() +} + +func TestEncodeMessage(t *testing.T) { + resetOpcodes() + o := RegisterMessage(Opcode(123), (*testMsg)(nil)) + + msg := testMsg{ + text: "hello", + } + + p := newPeer(nil, nil) + + bytes, err := p.EncodeMessage(msg) + assert.Nil(t, err) + assert.Equal(t, append([]byte{byte(o)}, msg.Write()...), bytes) +} + +func TestDecodeMessage(t *testing.T) { + resetOpcodes() + o := RegisterMessage(Opcode(45), (*testMsg)(nil)) + + msg := testMsg{ + text: "world", + } + assert.Equal(t, o, RegisterMessage(o, (*testMsg)(nil))) + + p := newPeer(nil, nil) + + resultO, resultM, err := p.DecodeMessage(append([]byte{byte(o)}, msg.Write()...)) + assert.Nil(t, err) + assert.Equal(t, o, resultO) + assert.Equal(t, msg, resultM) +}