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

@@ -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

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
+}

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")
 }

init.go

@@ -3,5 +3,7 @@ package noise
 import "go.dedis.ch/kyber/v3/suites"
 
 func init() {
+	resetOpcodes()
+
 	suites.RequireConstantTime()
 }

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
-}

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)
-}