[network] - merge networking.go into network.go

src/coin/skycoin/models/network.go

@@ -2,8 +2,10 @@ package skycoin
 
 import (
 	"encoding/hex"
+	"strings"
 
 	"github.com/SkycoinProject/skycoin/src/api"
+	"github.com/SkycoinProject/skycoin/src/readable"
 	"github.com/fibercrypto/fibercryptowallet/src/coin/skycoin/skytypes"
 	"github.com/fibercrypto/fibercryptowallet/src/core"
 	"github.com/fibercrypto/fibercryptowallet/src/errors"
@@ -135,3 +137,103 @@ func (spex *SkycoinPEX) GetTxnPool() (core.TransactionIterator, error) {
 	}
 	return NewSkycoinTransactionIterator(skycoinTxns), nil
 }
+
+type SkycoinPexNodeIterator struct {
+	//Implements PexNodeIterator interface
+	current  int
+	networks []core.PexNode
+}
+
+func (it *SkycoinPexNodeIterator) Value() core.PexNode {
+	return it.networks[it.current]
+}
+
+func (it *SkycoinPexNodeIterator) Next() bool {
+	if it.HasNext() {
+		it.current++
+		return true
+	}
+	return false
+}
+
+func (it *SkycoinPexNodeIterator) HasNext() bool {
+	return !((it.current + 1) >= len(it.networks))
+}
+
+func NewSkycoinPexNodeIterator(network []core.PexNode) *SkycoinPexNodeIterator {
+	return &SkycoinPexNodeIterator{networks: network, current: -1}
+}
+
+type SkycoinNetworkConnections struct {
+	//Implements NetworkSet interface
+	nodeAddress string
+}
+
+func NewSkycoinRemoteNetwork(nodeAddress string) *SkycoinNetworkConnections {
+	return &SkycoinNetworkConnections{nodeAddress}
+}
+
+func (remoteNetwork *SkycoinNetworkConnections) newClient() *api.Client {
+	return api.NewClient(remoteNetwork.nodeAddress)
+}
+
+func (remoteNetwork *SkycoinNetworkConnections) ListPeers() core.PexNodeIterator {
+	logNetwork.Info("Getting list of peers in Skycoin network connections")
+	c := remoteNetwork.newClient()
+	nets, err := c.NetworkConnections(nil)
+
+	if err != nil {
+		logNetwork.WithError(err).Warn("Couldn't get connections")
+		return nil
+	}
+	var netIterator []core.PexNode
+	for _, con := range nets.Connections {
+		netIterator = append(netIterator, connectionsToNetwork(con))
+	}
+
+	return NewSkycoinPexNodeIterator(netIterator)
+}
+
+type SkycoinPexNode struct {
+	Ip          string
+	Port        uint16
+	Source      bool
+	Block       uint64
+	LastSeenIn  int64
+	LastSeenOut int64
+}
+
+func (network *SkycoinPexNode) GetIp() string {
+	return network.Ip
+}
+
+func (network *SkycoinPexNode) GetPort() uint16 {
+	return network.Port
+}
+
+func (network *SkycoinPexNode) GetBlockHeight() uint64 {
+	return network.Block
+}
+
+func (network *SkycoinPexNode) IsTrusted() bool {
+	return network.Source
+}
+
+func (network *SkycoinPexNode) GetLastSeenIn() int64 {
+	return network.LastSeenIn
+}
+
+func (network *SkycoinPexNode) GetLastSeenOut() int64 {
+	return network.LastSeenOut
+}
+
+func connectionsToNetwork(connection readable.Connection) *SkycoinPexNode {
+	return &SkycoinPexNode{
+		Ip:          strings.Split(connection.Addr, ":")[0],
+		Port:        connection.ListenPort,
+		LastSeenIn:  connection.LastSent,
+		LastSeenOut: connection.LastReceived,
+		Block:       connection.Height,
+		Source:      connection.IsTrustedPeer,
+	}
+}

src/coin/skycoin/models/network_test.go

@@ -9,6 +9,8 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/SkycoinProject/skycoin/src/readable"
+	"github.com/fibercrypto/fibercryptowallet/src/coin/mocks"
+	"github.com/fibercrypto/fibercryptowallet/src/core"
 )
 
 func TestSkycoinPEXGetTxnPool(t *testing.T) {
@@ -91,3 +93,46 @@ func TestSkycoinPEXBroadcastTxn(t *testing.T) {
 	err = pex.BroadcastTxn(skyTxn)
 	require.NoError(t, err)
 }
+
+func TestSkycoinPexNode(t *testing.T) {
+	addr := "addr"
+	port := uint16(8000)
+	sent := int64(20)
+	recived := int64(42)
+	height := uint64(200)
+	trusted := true
+
+	conn := readable.Connection{
+		Addr:          addr,
+		ListenPort:    port,
+		LastSent:      sent,
+		LastReceived:  recived,
+		Height:        height,
+		IsTrustedPeer: trusted,
+	}
+	pex := connectionsToNetwork(conn)
+
+	require.Equal(t, addr, pex.GetIp())
+	require.Equal(t, port, pex.GetPort())
+	require.Equal(t, sent, pex.GetLastSeenIn())
+	require.Equal(t, recived, pex.GetLastSeenOut())
+	require.Equal(t, height, pex.GetBlockHeight())
+	require.Equal(t, trusted, pex.IsTrusted())
+}
+
+func TestSkycoinPexNodeIterator(t *testing.T) {
+	pexs := make([]core.PexNode, 0)
+	addrs := []string{"addr1", "addr2", "addr3"}
+	for _, addr := range addrs {
+		pex := &mocks.PexNode{}
+		pex.On("GetIp").Return(addr)
+		pexs = append(pexs, pex)
+	}
+
+	it := NewSkycoinPexNodeIterator(pexs)
+	for _, addr := range addrs {
+		require.Equal(t, true, it.Next())
+		require.Equal(t, addr, it.Value().GetIp())
+	}
+	require.Equal(t, false, it.Next())
+}