gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2024-09-20 15:26:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

modified getpeers for hub network

Browse source
This commit is contained in:
afeiszli 2022-02-18 11:43:49 -05:00
parent f55eeedbb9
commit 1c06cfc8f7
9 changed files with 135 additions and 274 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
controllers/node_grpc.go
View file

@ -232,12 +232,7 @@ func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*
return nil, err
}
excludeIsRelayed := node.IsRelay != "yes"
var relayedNode string
if node.IsRelayed == "yes" {
relayedNode = node.Address
}
peers, err := logic.GetPeersList(node.Network, excludeIsRelayed, relayedNode)
peers, err := logic.GetPeersList(&node)
if err != nil {
if strings.Contains(err.Error(), logic.RELAY_NODE_ERR) {
peers, err = logic.PeerListUnRelay(node.ID, node.Network)

4
database/database.go
View file

@ -32,9 +32,6 @@ const DNS_TABLE_NAME = "dns"
// EXT_CLIENT_TABLE_NAME - ext client table
const EXT_CLIENT_TABLE_NAME = "extclients"
// INT_CLIENTS_TABLE_NAME - int client table
const INT_CLIENTS_TABLE_NAME = "intclients"
// PEERS_TABLE_NAME - peers table
const PEERS_TABLE_NAME = "peers"
@ -126,7 +123,6 @@ func createTables() {
createTable(USERS_TABLE_NAME)
createTable(DNS_TABLE_NAME)
createTable(EXT_CLIENT_TABLE_NAME)
createTable(INT_CLIENTS_TABLE_NAME)
createTable(PEERS_TABLE_NAME)
createTable(SERVERCONF_TABLE_NAME)
createTable(SERVER_UUID_TABLE_NAME)

147
functions/helpers.go
View file

@ -2,100 +2,12 @@ package functions
import (
"encoding/json"
"log"
"strings"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
)
// ParseNode - parses a node into a model
func ParseNode(value string) (models.Node, error) {
var node models.Node
err := json.Unmarshal([]byte(value), &node)
return node, err
}
// ParseExtClient - parses an extclient into a model
func ParseExtClient(value string) (models.ExtClient, error) {
var extClient models.ExtClient
err := json.Unmarshal([]byte(value), &extClient)
return extClient, err
}
// ParseIntClient - parses int client
func ParseIntClient(value string) (models.IntClient, error) {
var intClient models.IntClient
err := json.Unmarshal([]byte(value), &intClient)
return intClient, err
}
// GetPeersList - gets peers for given network
func GetPeersList(networkName string) ([]models.PeersResponse, error) {
var peers []models.PeersResponse
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
return peers, err
}
for _, value := range collection {
var peer models.PeersResponse
err := json.Unmarshal([]byte(value), &peer)
if err != nil {
continue // try the rest
}
peers = append(peers, peer)
}
return peers, err
}
// GetIntPeersList - get int peers list
func GetIntPeersList() ([]models.PeersResponse, error) {
var peers []models.PeersResponse
records, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
if err != nil {
return peers, err
}
// parse the peers
for _, value := range records {
var peer models.PeersResponse
err := json.Unmarshal([]byte(value), &peer)
if err != nil {
log.Fatal(err)
}
// add the node to our node array
//maybe better to just return this? But then that's just GetNodes...
peers = append(peers, peer)
}
return peers, err
}
// GetServerIntClient - get server int client
func GetServerIntClient() (*models.IntClient, error) {
intClients, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
for _, value := range intClients {
var intClient models.IntClient
err = json.Unmarshal([]byte(value), &intClient)
if err != nil {
return nil, err
}
if intClient.IsServer == "yes" && intClient.Network == "comms" {
return &intClient, nil
}
}
return nil, err
}
// NetworkExists - check if network exists
func NetworkExists(name string) (bool, error) {
@ -107,34 +19,6 @@ func NetworkExists(name string) (bool, error) {
return len(network) > 0, nil
}
// IsKeyValidGlobal - checks if a key is valid globally
func IsKeyValidGlobal(keyvalue string) bool {
networks, _ := logic.GetNetworks()
var key models.AccessKey
foundkey := false
isvalid := false
for _, network := range networks {
for i := len(network.AccessKeys) - 1; i >= 0; i-- {
currentkey := network.AccessKeys[i]
if currentkey.Value == keyvalue {
key = currentkey
foundkey = true
break
}
}
if foundkey {
break
}
}
if foundkey {
if key.Uses > 0 {
isvalid = true
}
}
return isvalid
}
// NameInDNSCharSet - name in dns char set
func NameInDNSCharSet(name string) bool {
@ -166,37 +50,6 @@ func RemoveDeletedNode(nodeid string) bool {
return database.DeleteRecord(database.DELETED_NODES_TABLE_NAME, nodeid) == nil
}
// DeleteAllIntClients - delete all int clients
func DeleteAllIntClients() error {
err := database.DeleteAllRecords(database.INT_CLIENTS_TABLE_NAME)
if err != nil {
return err
}
return nil
}
// GetAllIntClients - get all int clients
func GetAllIntClients() ([]models.IntClient, error) {
var clients []models.IntClient
collection, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
if err != nil {
return clients, err
}
for _, value := range collection {
var client models.IntClient
err := json.Unmarshal([]byte(value), &client)
if err != nil {
return []models.IntClient{}, err
}
// add node to our array
clients = append(clients, client)
}
return clients, nil
}
// GetAllExtClients - get all ext clients
func GetAllExtClients() ([]models.ExtClient, error) {
var extclients []models.ExtClient

10
logic/networks.go
View file

@ -187,14 +187,8 @@ func UniqueAddress(networkName string) (string, error) {
offset = false
continue
}
if networkName == "comms" {
if IsIPUnique(networkName, ip.String(), database.INT_CLIENTS_TABLE_NAME, false) {
return ip.String(), err
}
} else {
if IsIPUnique(networkName, ip.String(), database.NODES_TABLE_NAME, false) && IsIPUnique(networkName, ip.String(), database.EXT_CLIENT_TABLE_NAME, false) {
return ip.String(), err
}
if IsIPUnique(networkName, ip.String(), database.NODES_TABLE_NAME, false) && IsIPUnique(networkName, ip.String(), database.EXT_CLIENT_TABLE_NAME, false) {
return ip.String(), err
}
}

7
logic/nodes.go
View file

@ -99,12 +99,7 @@ func GetPeers(node *models.Node) ([]models.Node, error) {
if IsLeader(node) {
setNetworkServerPeers(node)
}
excludeIsRelayed := node.IsRelay != "yes"
var relayedNode string
if node.IsRelayed == "yes" {
relayedNode = node.Address
}
peers, err := GetPeersList(node.Network, excludeIsRelayed, relayedNode)
peers, err := GetPeersList(node)
if err != nil {
if strings.Contains(err.Error(), RELAY_NODE_ERR) {
peers, err = PeerListUnRelay(node.ID, node.Network)

123
logic/peers.go
View file

@ -7,12 +7,135 @@ import (
"strings"
"time"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/logger"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/netclient/ncutils"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
)
// GetHubPeer - in HubAndSpoke networks, if not the hub, return the hub
func GetHubPeer(networkName string) []models.Node {
var hubpeer = make([]models.Node, 0)
servernodes, err := GetNetworkNodes(networkName)
if err != nil {
return hubpeer
}
for i := range servernodes {
if servernodes[i].IsHub == "yes" {
return []models.Node{servernodes[i]}
}
}
return hubpeer
}
// GetNodePeers - fetches peers for a given node
func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error) {
var peers []models.Node
var networkNodes, egressNetworkNodes, err = getNetworkEgressAndNodes(networkName)
if err != nil {
return peers, nil
}
udppeers, errN := database.GetPeers(networkName)
if errN != nil {
logger.Log(2, errN.Error())
}
for _, node := range networkNodes {
var peer = models.Node{}
if node.IsEgressGateway == "yes" { // handle egress stuff
peer.EgressGatewayRanges = node.EgressGatewayRanges
peer.IsEgressGateway = node.IsEgressGateway
}
allow := node.IsRelayed != "yes" || !excludeRelayed
if node.Network == networkName && node.IsPending != "yes" && allow {
peer = setPeerInfo(&node)
if node.UDPHolePunch == "yes" && errN == nil && CheckEndpoint(udppeers[node.PublicKey]) {
endpointstring := udppeers[node.PublicKey]
endpointarr := strings.Split(endpointstring, ":")
if len(endpointarr) == 2 {
port, err := strconv.Atoi(endpointarr[1])
if err == nil {
// peer.Endpoint = endpointarr[0]
peer.ListenPort = int32(port)
}
}
}
if node.IsRelay == "yes" {
network, err := GetNetwork(networkName)
if err == nil {
peer.AllowedIPs = append(peer.AllowedIPs, network.AddressRange)
} else {
peer.AllowedIPs = append(peer.AllowedIPs, node.RelayAddrs...)
}
for _, egressNode := range egressNetworkNodes {
if egressNode.IsRelayed == "yes" && StringSliceContains(node.RelayAddrs, egressNode.Address) {
peer.AllowedIPs = append(peer.AllowedIPs, egressNode.EgressGatewayRanges...)
}
}
}
peers = append(peers, peer)
}
}
return peers, err
}
// GetPeersList - gets the peers of a given network
func GetPeersList(refnode *models.Node) ([]models.Node, error) {
var peers []models.Node
var err error
var networkName = refnode.Network
var excludeRelayed = refnode.IsRelay != "yes"
var relayedNodeAddr string
if refnode.IsRelayed == "yes" {
relayedNodeAddr = refnode.Address
}
network, err := GetNetwork(networkName)
if err != nil {
return peers, err
} else if network.IsHubAndSpoke == "yes" && refnode.IsHub != "yes" {
return GetHubPeer(networkName), nil
}
if relayedNodeAddr == "" {
peers, err = GetNodePeers(networkName, excludeRelayed)
} else {
var relayNode models.Node
relayNode, err = GetNodeRelay(networkName, relayedNodeAddr)
if relayNode.Address != "" {
var peerNode = setPeerInfo(&relayNode)
network, err := GetNetwork(networkName)
if err == nil {
peerNode.AllowedIPs = append(peerNode.AllowedIPs, network.AddressRange)
var _, egressNetworkNodes, err = getNetworkEgressAndNodes(networkName)
if err == nil {
for _, egress := range egressNetworkNodes {
if egress.Address != relayedNodeAddr {
peerNode.AllowedIPs = append(peerNode.AllowedIPs, egress.EgressGatewayRanges...)
}
}
}
} else {
peerNode.AllowedIPs = append(peerNode.AllowedIPs, peerNode.RelayAddrs...)
}
nodepeers, err := GetNodePeers(networkName, false)
if err == nil && peerNode.UDPHolePunch == "yes" {
for _, nodepeer := range nodepeers {
if nodepeer.Address == peerNode.Address {
// peerNode.Endpoint = nodepeer.Endpoint
peerNode.ListenPort = nodepeer.ListenPort
}
}
}
peers = append(peers, peerNode)
}
}
return peers, err
}
// GetPeerUpdate - gets a wireguard peer config for each peer of a node
func GetPeerUpdate(node *models.Node) (models.PeerUpdate, error) {
var peerUpdate models.PeerUpdate

14
logic/relay.go
View file

@ -89,14 +89,14 @@ func SetRelayedNodes(yesOrno string, networkName string, addrs []string) ([]mode
}
// SetNodeIsRelayed - Sets IsRelayed to on or off for relay
func SetNodeIsRelayed(yesOrno string, id string) error {
func SetNodeIsRelayed(yesOrno string, id string) (models.Node, error) {
node, err := GetNodeByID(id)
if err != nil {
return err
return node, err
}
network, err := GetNetworkByNode(&node)
if err != nil {
return err
return node, err
}
node.IsRelayed = yesOrno
if yesOrno == "yes" {
@ -106,18 +106,18 @@ func SetNodeIsRelayed(yesOrno string, id string) error {
}
data, err := json.Marshal(&node)
if err != nil {
return err
return node, err
}
return database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
return node, database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
}
// PeerListUnRelay - call this function if a relayed node fails to get its relay: unrelays node and gets new peer list
func PeerListUnRelay(id string, network string) ([]models.Node, error) {
err := SetNodeIsRelayed("no", id)
node, err := SetNodeIsRelayed("no", id)
if err != nil {
return nil, err
}
return GetPeersList(network, true, "")
return GetPeersList(&node)
}
// ValidateRelay - checks if relay is valid

96
logic/util.go
View file

@ -10,7 +10,6 @@ import (
"math/rand"
"net"
"os"
"strconv"
"strings"
"time"
@ -130,101 +129,6 @@ func DeleteNodeByID(node *models.Node, exterminate bool) error {
return removeLocalServer(node)
}
// GetNodePeers - fetches peers for a given node
func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error) {
var peers []models.Node
var networkNodes, egressNetworkNodes, err = getNetworkEgressAndNodes(networkName)
if err != nil {
return peers, nil
}
udppeers, errN := database.GetPeers(networkName)
if errN != nil {
logger.Log(2, errN.Error())
}
for _, node := range networkNodes {
var peer = models.Node{}
if node.IsEgressGateway == "yes" { // handle egress stuff
peer.EgressGatewayRanges = node.EgressGatewayRanges
peer.IsEgressGateway = node.IsEgressGateway
}
allow := node.IsRelayed != "yes" || !excludeRelayed
if node.Network == networkName && node.IsPending != "yes" && allow {
peer = setPeerInfo(&node)
if node.UDPHolePunch == "yes" && errN == nil && CheckEndpoint(udppeers[node.PublicKey]) {
endpointstring := udppeers[node.PublicKey]
endpointarr := strings.Split(endpointstring, ":")
if len(endpointarr) == 2 {
port, err := strconv.Atoi(endpointarr[1])
if err == nil {
// peer.Endpoint = endpointarr[0]
peer.ListenPort = int32(port)
}
}
}
if node.IsRelay == "yes" {
network, err := GetNetwork(networkName)
if err == nil {
peer.AllowedIPs = append(peer.AllowedIPs, network.AddressRange)
} else {
peer.AllowedIPs = append(peer.AllowedIPs, node.RelayAddrs...)
}
for _, egressNode := range egressNetworkNodes {
if egressNode.IsRelayed == "yes" && StringSliceContains(node.RelayAddrs, egressNode.Address) {
peer.AllowedIPs = append(peer.AllowedIPs, egressNode.EgressGatewayRanges...)
}
}
}
peers = append(peers, peer)
}
}
return peers, err
}
// GetPeersList - gets the peers of a given network
func GetPeersList(networkName string, excludeRelayed bool, relayedNodeAddr string) ([]models.Node, error) {
var peers []models.Node
var err error
if relayedNodeAddr == "" {
peers, err = GetNodePeers(networkName, excludeRelayed)
} else {
var relayNode models.Node
relayNode, err = GetNodeRelay(networkName, relayedNodeAddr)
if relayNode.Address != "" {
var peerNode = setPeerInfo(&relayNode)
network, err := GetNetwork(networkName)
if err == nil {
peerNode.AllowedIPs = append(peerNode.AllowedIPs, network.AddressRange)
var _, egressNetworkNodes, err = getNetworkEgressAndNodes(networkName)
if err == nil {
for _, egress := range egressNetworkNodes {
if egress.Address != relayedNodeAddr {
peerNode.AllowedIPs = append(peerNode.AllowedIPs, egress.EgressGatewayRanges...)
}
}
}
} else {
peerNode.AllowedIPs = append(peerNode.AllowedIPs, peerNode.RelayAddrs...)
}
nodepeers, err := GetNodePeers(networkName, false)
if err == nil && peerNode.UDPHolePunch == "yes" {
for _, nodepeer := range nodepeers {
if nodepeer.Address == peerNode.Address {
// peerNode.Endpoint = nodepeer.Endpoint
peerNode.ListenPort = nodepeer.ListenPort
}
}
}
peers = append(peers, peerNode)
}
}
return peers, err
}
// RandomString - returns a random string in a charset
func RandomString(length int) string {
const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

1
serverctl/serverctl.go
View file

@ -22,6 +22,7 @@ const (
COMMS_NETID = "n37m8k3r"
)
// InitializeCommsNetwork - Check if comms network exists (for MQ, DNS, SSH traffic), if not, create
func InitializeCommsNetwork() error {
_, err := logic.GetNetwork(COMMS_NETID)