replaced sync.Map with own type (#189)

* replaced sync.Map with own type

* fixed map test

.gitignore

@@ -22,7 +22,7 @@
 bio-rd
 examples/bgp
 examples/bmp
-examples/netlink/netlink
+examples/fib/fib
 
 # bazel directories
 /bazel-*

protocols/bgp/server/peer_manager.go

+package server
+
+import (
+	"sync"
+
+	bnet "github.com/bio-routing/bio-rd/net"
+)
+
+type peerManager struct {
+	peers   map[bnet.IP]*peer
+	peersMu sync.RWMutex
+}
+
+func newPeerManager() *peerManager {
+	return &peerManager{
+		peers: make(map[bnet.IP]*peer),
+	}
+}
+
+func (m *peerManager) add(p *peer) {
+	m.peersMu.Lock()
+	defer m.peersMu.Unlock()
+
+	m.peers[p.GetAddr()] = p
+}
+
+func (m *peerManager) remove(neighborIP bnet.IP) {
+	m.peersMu.Lock()
+	defer m.peersMu.Unlock()
+
+	delete(m.peers, neighborIP)
+}
+
+func (m *peerManager) get(neighborIP bnet.IP) *peer {
+	m.peersMu.RLock()
+	defer m.peersMu.RUnlock()
+
+	p, _ := m.peers[neighborIP]
+	return p
+}
+
+func (m *peerManager) list() []*peer {
+	m.peersMu.RLock()
+	defer m.peersMu.RUnlock()
+
+	res := make([]*peer, len(m.peers))
+	i := 0
+	for _, p := range m.peers {
+		res[i] = p
+		i++
+	}
+
+	return res
+}

protocols/bgp/server/peer_manager_test.go

+package server
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	bnet "github.com/bio-routing/bio-rd/net"
+)
+
+func TestAdd(t *testing.T) {
+	ip := bnet.IPv4FromOctets(192, 168, 0, 1)
+	p := &peer{
+		addr: ip,
+	}
+
+	m := newPeerManager()
+	m.add(p)
+
+	found, _ := m.peers[ip]
+	assert.Exactly(t, p, found)
+}
+
+func TestRemove(t *testing.T) {
+	ip := bnet.IPv4FromOctets(192, 168, 0, 1)
+	p := &peer{
+		addr: ip,
+	}
+
+	m := newPeerManager()
+	m.peers[ip] = p
+
+	m.remove(ip)
+
+	assert.Empty(t, m.peers)
+}
+
+func TestGet(t *testing.T) {
+	ip := bnet.IPv4FromOctets(192, 168, 0, 1)
+	p := &peer{
+		addr: ip,
+	}
+
+	m := newPeerManager()
+	m.peers[ip] = p
+
+	found := m.get(ip)
+	assert.Exactly(t, p, found)
+}
+
+func TestList(t *testing.T) {
+	p1 := &peer{
+		addr: bnet.IPv4FromOctets(192, 168, 0, 1),
+	}
+	p2 := &peer{
+		addr: bnet.IPv4FromOctets(192, 168, 0, 2),
+	}
+
+	m := newPeerManager()
+	m.peers[p1.GetAddr()] = p1
+	m.peers[p2.GetAddr()] = p2
+
+	list := m.list()
+	assert.Contains(t, list, p1)
+	assert.Contains(t, list, p2)
+}

protocols/bgp/server/server.go

@@ -2,10 +2,9 @@ package server
 
 import (
 	"net"
-	"strings"
-	"sync"
 
 	"github.com/bio-routing/bio-rd/config"
+	bnetutils "github.com/bio-routing/bio-rd/util/net"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 )
@@ -17,7 +16,7 @@ const (
 type bgpServer struct {
 	listeners []*TCPListener
 	acceptCh  chan *net.TCPConn
-	peers     sync.Map
+	peers     *peerManager
 	routerID  uint32
 	localASN  uint32
 }
@@ -66,16 +65,16 @@ func (b *bgpServer) incomingConnectionWorker() {
 	for {
 		c := <-b.acceptCh
 
-		peerAddr := strings.Split(c.RemoteAddr().String(), ":")[0]
-		peerInterface, ok := b.peers.Load(peerAddr)
-		if !ok {
+		peerAddr, _ := bnetutils.BIONetIPFromAddr(c.RemoteAddr().String())
+
+		peer := b.peers.get(peerAddr)
+		if peer == nil {
 			c.Close()
 			log.WithFields(log.Fields{
 				"source": c.RemoteAddr(),
 			}).Warning("TCP connection from unknown source")
 			continue
 		}
-		peer := peerInterface.(*peer)
 
 		log.WithFields(log.Fields{
 			"source": c.RemoteAddr(),
@@ -102,8 +101,7 @@ func (b *bgpServer) AddPeer(c config.Peer) error {
 	}
 
 	peer.routerID = c.RouterID
-	peerAddr := peer.GetAddr().String()
-	b.peers.Store(peerAddr, peer)
+	b.peers.add(peer)
 	peer.Start()
 
 	return nil

util/net/net_addr.go

+package net
+
+import (
+	"net"
+
+	bnet "github.com/bio-routing/bio-rd/net"
+)
+
+// BIONetIPFromAddr retrives the IP from an net.Addr and returns the IP in BIO's internal IP type
+func BIONetIPFromAddr(hostPort string) (bnet.IP, error) {
+	host, _, err := net.SplitHostPort(hostPort)
+	if err != nil {
+		return bnet.IP{}, err
+	}
+
+	return bnet.IPFromString(host)
+}

util/net/net_addr_test.go

+package net
+
+import (
+	"testing"
+
+	bnet "github.com/bio-routing/bio-rd/net"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBIONetIPFromAddr(t *testing.T) {
+	tests := []struct {
+		name     string
+		hostPort string
+		expected bnet.IP
+		wantFail bool
+	}{
+		{
+			name:     "IPv6",
+			hostPort: "[2001:678:1e0::1]:80",
+			expected: bnet.IPv6FromBlocks(0x2001, 0x678, 0x01e0, 0, 0, 0, 0, 1),
+		},
+		{
+			name:     "IPv4",
+			hostPort: "192.168.1.1:80",
+			expected: bnet.IPv4FromOctets(192, 168, 1, 1),
+		},
+		{
+			name:     "hostname",
+			hostPort: "myhost:80",
+			wantFail: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			ip, err := BIONetIPFromAddr(test.hostPort)
+			if err != nil {
+				if test.wantFail {
+					return
+				}
+
+				t.Fatal(err)
+			}
+
+			assert.Equal(t, ip, test.expected)
+		})
+	}
+}