dex: redesign p2p network topology

- Let p2p server support direct connection and group connection.
- Introduce node meta table to maintain IP of all nodes in node set,
  in memory and let nodes in the network can sync this table.
- Let peerSet able to manage direct connections to notary set and dkg set.

The mechanism to refresh the network topology when configuration round
change is not done yet.

1 files changed, 0 insertions, 203 deletions

diff --git a/dex/notaryset.go b/dex/notaryset.go
deleted file mode 100644
index 74d259314..000000000
--- a/dex/notaryset.go
+++ /dev/null
@@ -1,203 +0,0 @@
-package dex
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/dexon-foundation/dexon/p2p/discover"
-)
-
-type nodeInfo struct {
-	info  *notaryNodeInfo
-	added bool
-}
-
-func (n *nodeInfo) NewNode() *discover.Node {
-	return discover.NewNode(n.info.ID, n.info.IP, n.info.UDP, n.info.TCP)
-}
-
-type notarySet struct {
-	round uint64
-	m     map[string]*nodeInfo
-	lock  sync.RWMutex
-}
-
-func newNotarySet(round uint64, s map[string]struct{}) *notarySet {
-	m := make(map[string]*nodeInfo)
-	for nodeID := range s {
-		m[nodeID] = &nodeInfo{}
-	}
-
-	return &notarySet{
-		round: round,
-		m:     m,
-	}
-}
-
-// Call this function when the notaryNodeInfoMsg is received.
-func (n *notarySet) AddInfo(info *notaryNodeInfo) error {
-	n.lock.Lock()
-	defer n.lock.Unlock()
-
-	// check round
-	if info.Round != n.round {
-		return fmt.Errorf("invalid round")
-	}
-
-	nInfo, ok := n.m[info.ID.String()]
-	if !ok {
-		return fmt.Errorf("not in notary set")
-	}
-
-	// if the info exists check timstamp
-	if nInfo.info != nil {
-		if nInfo.info.Timestamp > info.Timestamp {
-			return fmt.Errorf("old msg")
-		}
-	}
-
-	nInfo.info = info
-	return nil
-}
-
-// MarkAdded mark the notary node as added
-// to prevent duplcate addition in the future.
-func (n *notarySet) MarkAdded(nodeID string) {
-	if info, ok := n.m[nodeID]; ok {
-		info.added = true
-	}
-}
-
-// Return all nodes
-func (n *notarySet) Nodes() []*discover.Node {
-	n.lock.RLock()
-	defer n.lock.RUnlock()
-
-	list := make([]*discover.Node, 0, len(n.m))
-	for _, info := range n.m {
-		list = append(list, info.NewNode())
-	}
-	return list
-}
-
-// Return nodes that need to be added to p2p server as notary node.
-func (n *notarySet) NodesToAdd() []*discover.Node {
-	n.lock.RLock()
-	defer n.lock.RUnlock()
-
-	var list []*discover.Node
-	for _, info := range n.m {
-		// craete a new discover.Node
-		if !info.added {
-			list = append(list, info.NewNode())
-		}
-	}
-	return list
-}
-
-type notarySetManager struct {
-	m                   map[uint64]*notarySet
-	lock                sync.RWMutex
-	queued              map[uint64]map[string]*notaryNodeInfo
-	round               uint64 // biggest round of managed notary sets
-	newNotaryNodeInfoCh chan *notaryNodeInfo
-}
-
-func newNotarySetManager(
-	newNotaryNodeInfoCh chan *notaryNodeInfo) *notarySetManager {
-	return &notarySetManager{
-		m:                   make(map[uint64]*notarySet),
-		queued:              make(map[uint64]map[string]*notaryNodeInfo),
-		newNotaryNodeInfoCh: newNotaryNodeInfoCh,
-	}
-}
-
-// Register injects a new notary set into the manager and
-// processes the queued info.
-func (n *notarySetManager) Register(r uint64, s *notarySet) {
-	n.lock.Lock()
-	defer n.lock.Unlock()
-	if r > n.round {
-		n.round = r
-	}
-	n.m[r] = s
-	n.processQueuedInfo()
-}
-
-// Unregister removes the notary set of the given round.
-func (n *notarySetManager) Unregister(r uint64) {
-	n.lock.Lock()
-	defer n.lock.Unlock()
-	delete(n.m, r)
-}
-
-// Round returns the notary set of the given round.
-func (n *notarySetManager) Round(r uint64) (*notarySet, bool) {
-	n.lock.RLock()
-	defer n.lock.RUnlock()
-	s, ok := n.m[r]
-	return s, ok
-}
-
-// Before returns all the notary sets that before the given round.
-func (n *notarySetManager) Before(r uint64) []*notarySet {
-	n.lock.RLock()
-	defer n.lock.RUnlock()
-	var list []*notarySet
-	for round, s := range n.m {
-		if round < r {
-			list = append(list, s)
-		}
-	}
-	return list
-}
-
-// TryAddInfo associates the given info to the notary set if the notary set is
-// managed by the manager.
-// If the notary node info is belong to future notary set, queue the info.
-func (n *notarySetManager) TryAddInfo(info *notaryNodeInfo) {
-	n.lock.Lock()
-	defer n.lock.Unlock()
-	n.tryAddInfo(info)
-}
-
-// This function is extract for calling without lock.
-// Make sure the caller already accquired the lock.
-func (n *notarySetManager) tryAddInfo(info *notaryNodeInfo) {
-	if info.Round > n.round {
-		if q, ok := n.queued[info.Round]; ok {
-			q[info.Hash().String()] = info
-			return
-		}
-		n.queued[info.Round] = map[string]*notaryNodeInfo{
-			info.Hash().String(): info,
-		}
-		return
-	}
-
-	s, ok := n.Round(info.Round)
-	if !ok {
-		return
-	}
-	s.AddInfo(info)
-
-	// TODO(sonic): handle timeout
-	n.newNotaryNodeInfoCh <- info
-}
-
-func (n *notarySetManager) processQueuedInfo() {
-	n.lock.Lock()
-	defer n.lock.Unlock()
-	if q, ok := n.queued[n.round]; ok {
-		for _, info := range q {
-			n.tryAddInfo(info)
-		}
-	}
-
-	// Clear queue infos before current round.
-	for round := range n.queued {
-		if round <= n.round {
-			delete(n.queued, round)
-		}
-	}
-}