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

rebase

Browse source 
Signed-off-by: Matthew R. Kasun <mkasun@nusak.ca>
This commit is contained in:
Matthew R. Kasun 2022-12-19 15:15:35 -05:00
parent a5e6aea563
commit c086e9499d
40 changed files with 463 additions and 337 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
controllers/dns_test.go
View file

@ -53,7 +53,7 @@ func TestGetNodeDNS(t *testing.T) {
assert.Equal(t, "10.0.0.1", dns[0].Address)
})
t.Run("MultipleNodes", func(t *testing.T) {
createnode := &models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.100.100.3", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet"}
createnode := &models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.100.100.3", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet"}
err := logic.CreateNode(createnode)
assert.Nil(t, err)
dns, err := logic.GetNodeDNS("skynet")
@ -249,33 +249,33 @@ func TestGetDNSEntry(t *testing.T) {
})
}
// func TestUpdateDNS(t *testing.T) {
// var newentry models.DNSEntry
// database.InitializeDatabase()
// deleteAllDNS(t)
// deleteAllNetworks()
// createNet()
// entry := models.DNSEntry{"10.0.0.2", "newhost", "skynet"}
// CreateDNS(entry)
// t.Run("change address", func(t *testing.T) {
// newentry.Address = "10.0.0.75"
// updated, err := UpdateDNS(newentry, entry)
// assert.Nil(t, err)
// assert.Equal(t, newentry.Address, updated.Address)
// })
// t.Run("change name", func(t *testing.T) {
// newentry.Name = "newname"
// updated, err := UpdateDNS(newentry, entry)
// assert.Nil(t, err)
// assert.Equal(t, newentry.Name, updated.Name)
// })
// t.Run("change network", func(t *testing.T) {
// newentry.Network = "wirecat"
// updated, err := UpdateDNS(newentry, entry)
// assert.Nil(t, err)
// assert.NotEqual(t, newentry.Network, updated.Network)
// })
// }
// func TestUpdateDNS(t *testing.T) {
// var newentry models.DNSEntry
// database.InitializeDatabase()
// deleteAllDNS(t)
// deleteAllNetworks()
// createNet()
// entry := models.DNSEntry{"10.0.0.2", "newhost", "skynet"}
// CreateDNS(entry)
// t.Run("change address", func(t *testing.T) {
// newentry.Address = "10.0.0.75"
// updated, err := UpdateDNS(newentry, entry)
// assert.Nil(t, err)
// assert.Equal(t, newentry.Address, updated.Address)
// })
// t.Run("change name", func(t *testing.T) {
// newentry.Name = "newname"
// updated, err := UpdateDNS(newentry, entry)
// assert.Nil(t, err)
// assert.Equal(t, newentry.Name, updated.Name)
// })
// t.Run("change network", func(t *testing.T) {
// newentry.Network = "wirecat"
// updated, err := UpdateDNS(newentry, entry)
// assert.Nil(t, err)
// assert.NotEqual(t, newentry.Network, updated.Network)
// })
// }
func TestDeleteDNS(t *testing.T) {
database.InitializeDatabase()
deleteAllDNS(t)

6
controllers/docs.go
View file

@ -243,21 +243,21 @@ type aclContainerResponse struct {
type nodeSliceResponse struct {
// Nodes
// in: body
Nodes []models.Node `json:"nodes"`
Nodes []models.LegacyNode `json:"nodes"`
}
// swagger:response nodeResponse
type nodeResponse struct {
// Node
// in: body
Node models.Node `json:"node"`
Node models.LegacyNode `json:"node"`
}
// swagger:parameters updateNode deleteNode
type nodeBodyParam struct {
// Node
// in: body
Node models.Node `json:"node"`
Node models.LegacyNode `json:"node"`
}
// swagger:parameters createRelay

2
controllers/network_test.go
View file

@ -305,7 +305,7 @@ func TestIpv6Network(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, network.AddressRange6, "fde6:be04:fa5e:d076::/64")
})
node1 := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.50", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet6", OS: "linux"}
node1 := models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.50", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet6", OS: "linux"}
nodeErr := logic.CreateNode(&node1)
t.Run("Test node on network IPv6", func(t *testing.T) {
assert.Nil(t, nodeErr)

135
controllers/node.go
View file

@ -53,7 +53,7 @@ func nodeHandlers(r *mux.Router) {
func authenticate(response http.ResponseWriter, request *http.Request) {
var authRequest models.AuthParams
var result models.Node
var result models.LegacyNode
var errorResponse = models.ErrorResponse{
Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
}
@ -357,7 +357,7 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var nodes []models.Node
var nodes []models.LegacyNode
var params = mux.Vars(r)
networkName := params["network"]
@ -403,7 +403,7 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
return
}
var nodes []models.Node
var nodes []models.LegacyNode
if user.IsAdmin || r.Header.Get("ismasterkey") == "yes" {
nodes, err = logic.GetAllNodes()
if err != nil {
@ -426,8 +426,8 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(nodes)
}
func getUsersNodes(user models.User) ([]models.Node, error) {
var nodes []models.Node
func getUsersNodes(user models.User) ([]models.LegacyNode, error) {
var nodes []models.LegacyNode
var err error
for _, networkName := range user.Networks {
tmpNodes, err := logic.GetNetworkNodes(networkName)
@ -479,8 +479,8 @@ func getNode(w http.ResponseWriter, r *http.Request) {
}
response := models.NodeGet{
Node: node,
Peers: peerUpdate.Peers,
Node: node,
//Peers: peerUpdate.Peers,
ServerConfig: servercfg.GetServerInfo(),
PeerIDs: peerUpdate.PeerIDs,
}
@ -541,60 +541,47 @@ func createNode(w http.ResponseWriter, r *http.Request) {
return
}
var node = models.Node{}
//get node from body of request
err = json.NewDecoder(r.Body).Decode(&node)
//get data from body of request
data := models.JoinData{}
err = json.NewDecoder(r.Body).Decode(&data)
if err != nil {
logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
return
}
if !logic.IsVersionComptatible(node.Version) {
if !logic.IsVersionComptatible(data.Host.Version) {
err := errors.New("incomatible netclient version")
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
return
}
node.Network = networkName
data.Node.Network = networkName
network, err := logic.GetNetworkByNode(&node)
networkSettings, err := logic.GetNetworkSettings(networkName)
if err != nil {
logger.Log(0, r.Header.Get("user"),
fmt.Sprintf("failed to get network [%s] info: %v", node.Network, err))
fmt.Sprintf("failed to get network [%s] settings: %v", networkName, err))
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
return
}
node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
if err != nil {
logger.Log(0, r.Header.Get("user"),
fmt.Sprintf("failed to get network [%s] settings: %v", node.Network, err))
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
return
}
keyName, validKey := logic.IsKeyValid(networkName, node.AccessKey)
data.Node.NetworkSettings(networkSettings)
keyName, validKey := logic.IsKeyValid(networkName, data.Key)
if !validKey {
// Check to see if network will allow manual sign up
// may want to switch this up with the valid key check and avoid a DB call that way.
if network.AllowManualSignUp == "yes" {
node.IsPending = "yes"
} else {
errorResponse = models.ErrorResponse{
Code: http.StatusUnauthorized, Message: "W1R3: Key invalid, or none provided.",
}
logger.Log(0, r.Header.Get("user"),
fmt.Sprintf("failed to create node on network [%s]: %s",
node.Network, errorResponse.Message))
logic.ReturnErrorResponse(w, r, errorResponse)
return
errorResponse = models.ErrorResponse{
Code: http.StatusUnauthorized, Message: "W1R3: Key invalid, or none provided.",
}
logger.Log(0, r.Header.Get("user"),
fmt.Sprintf("failed to create node on network [%s]: %s",
data.Node.Network, errorResponse.Message))
logic.ReturnErrorResponse(w, r, errorResponse)
return
}
user, err := pro.GetNetworkUser(networkName, promodels.NetworkUserID(keyName))
if err == nil {
if user.ID != "" {
logger.Log(1, "associating new node with user", keyName)
node.OwnerID = string(user.ID)
data.Node.OwnerID = string(user.ID)
}
}
@ -609,23 +596,22 @@ func createNode(w http.ResponseWriter, r *http.Request) {
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
return
}
if node.TrafficKeys.Mine == nil {
if data.Host.TrafficKeyPublic == nil {
logger.Log(0, "error: node traffic key is nil")
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
return
}
node.TrafficKeys = models.TrafficKeys{
Mine: node.TrafficKeys.Mine,
Server: key,
}
server := servercfg.GetServerInfo()
server.TrafficKey = key
// consume password before hashing for mq client creation
nodePassword := node.Password
node.Server = servercfg.GetServer()
err = logic.CreateNode(&node)
nodePassword := data.Host.HostPass
data.Node.Server = servercfg.GetServer()
err = logic.CreateNode(&data.Node)
if err != nil {
logger.Log(0, r.Header.Get("user"),
fmt.Sprintf("failed to create node on network [%s]: %s",
node.Network, err))
networkName, err))
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
return
}
@ -635,52 +621,53 @@ func createNode(w http.ResponseWriter, r *http.Request) {
// if it fails remove the node and fail request
if user != nil {
var updatedUserNode bool
user.Nodes = append(user.Nodes, node.ID) // add new node to user
user.Nodes = append(user.Nodes, data.Node.ID.String()) // add new node to user
if err = pro.UpdateNetworkUser(networkName, user); err == nil {
logger.Log(1, "added node", node.ID, node.Name, "to user", string(user.ID))
logger.Log(1, "added node", data.Node.ID.String(), data.Host.Name, "to user", string(user.ID))
updatedUserNode = true
}
if !updatedUserNode { // user was found but not updated, so delete node
logger.Log(0, "failed to add node to user", keyName)
logic.DeleteNode(&node, true)
logic.DeleteNode(&data.Node, true)
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
return
}
}
peerUpdate, err := logic.GetPeerUpdate(&node)
peerUpdate, err := logic.GetPeerUpdate(&data.Node)
if err != nil && !database.IsEmptyRecord(err) {
logger.Log(0, r.Header.Get("user"),
fmt.Sprintf("error fetching wg peers config for node [ %s ]: %v", node.ID, err))
fmt.Sprintf("error fetching wg peers config for node [ %s ]: %v", data.Node.ID.String(), err))
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
return
}
data.Node.Peers = peerUpdate.Peers
// Create client for this host in Mq
event := mq.MqDynsecPayload{
Commands: []mq.MqDynSecCmd{
{ // delete if any client exists already
Command: mq.DeleteClientCmd,
Username: node.HostID,
Username: data.Host.ID.String(),
},
{
Command: mq.CreateRoleCmd,
RoleName: node.Network,
RoleName: networkName,
Textname: "Network wide role with Acls for nodes",
Acls: mq.FetchNetworkAcls(node.Network),
Acls: mq.FetchNetworkAcls(networkName),
},
{
Command: mq.CreateClientCmd,
Username: node.HostID,
Username: data.Host.ID.String(),
Password: nodePassword,
Textname: node.Name,
Textname: data.Host.Name,
Roles: []mq.MqDynSecRole{
{
Rolename: mq.NodeRole,
Priority: -1,
},
{
Rolename: node.Network,
Rolename: networkName,
Priority: -1,
},
},
@ -695,16 +682,26 @@ func createNode(w http.ResponseWriter, r *http.Request) {
}
response := models.NodeGet{
Node: node,
Peers: peerUpdate.Peers,
ServerConfig: servercfg.GetServerInfo(),
Node: data.Node,
//Peers: peerUpdate.Peers,
ServerConfig: server,
PeerIDs: peerUpdate.PeerIDs,
}
logger.Log(1, r.Header.Get("user"), "created new node", node.Name, "on network", node.Network)
//host, newNode := node.ConvertToNewNode()
logic.SaveHost(data.Host)
logic.SaveNode(data.Node)
logger.Log(1, r.Header.Get("user"), "created new node", data.Host.Name, "on network", networkName)
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(response)
runForceServerUpdate(&node, true)
go func() {
if err := mq.PublishPeerUpdate(data.Node, true); err != nil {
logger.Log(1, "failed a peer update after creation of node", data.Host.Name)
}
}()
//runForceServerUpdate(&data.Node, true)
}
// swagger:route POST /api/nodes/{network}/{nodeid}/approve nodes uncordonNode
@ -912,7 +909,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
var params = mux.Vars(r)
var node models.Node
var node models.LegacyNode
//start here
nodeid := params["nodeid"]
node, err := logic.GetNodeByID(nodeid)
@ -923,7 +920,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
return
}
var newNode models.Node
var newNode models.LegacyNode
// we decode our body request params
err = json.NewDecoder(r.Body).Decode(&newNode)
if err != nil {
@ -1088,7 +1085,7 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
runForceServerUpdate(&node, false)
}
func runUpdates(node *models.Node, ifaceDelta bool) {
func runUpdates(node *models.LegacyNode, ifaceDelta bool) {
go func() { // don't block http response
// publish node update if not server
if err := mq.NodeUpdate(node); err != nil {
@ -1103,7 +1100,7 @@ func runUpdates(node *models.Node, ifaceDelta bool) {
}
// updates local peers for a server on a given node's network
func runServerUpdate(node *models.Node, ifaceDelta bool) error {
func runServerUpdate(node *models.LegacyNode, ifaceDelta bool) error {
if servercfg.IsClientMode() != "on" || !isServer(node) {
return nil
}
@ -1126,7 +1123,7 @@ func runServerUpdate(node *models.Node, ifaceDelta bool) error {
return nil
}
func runForceServerUpdate(node *models.Node, publishPeerUpdateToNode bool) {
func runForceServerUpdate(node *models.LegacyNode, publishPeerUpdateToNode bool) {
go func() {
if err := mq.PublishPeerUpdate(node, publishPeerUpdateToNode); err != nil {
logger.Log(1, "failed a peer update after creation of node", node.Name)
@ -1141,11 +1138,11 @@ func runForceServerUpdate(node *models.Node, publishPeerUpdateToNode bool) {
}()
}
func isServer(node *models.Node) bool {
func isServer(node *models.LegacyNode) bool {
return node.IsServer == "yes"
}
func updateRelay(oldnode, newnode *models.Node) {
func updateRelay(oldnode, newnode *models.LegacyNode) {
relay := logic.FindRelay(oldnode)
newrelay := relay
//check if node's address has been updated and if so, update the relayAddrs of the relay node with the updated address of the relayed node

22
controllers/node_test.go
View file

@ -21,16 +21,16 @@ func TestCreateEgressGateway(t *testing.T) {
createNet()
t.Run("NoNodes", func(t *testing.T) {
node, err := logic.CreateEgressGateway(gateway)
assert.Equal(t, models.Node{}, node)
assert.Equal(t, models.LegacyNode{}, node)
assert.EqualError(t, err, "could not find any records")
})
t.Run("Non-linux node", func(t *testing.T) {
createnode := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "windows"}
createnode := models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "windows"}
err := logic.CreateNode(&createnode)
assert.Nil(t, err)
gateway.NodeID = createnode.ID
node, err := logic.CreateEgressGateway(gateway)
assert.Equal(t, models.Node{}, node)
assert.Equal(t, models.LegacyNode{}, node)
assert.EqualError(t, err, "windows is unsupported for egress gateways")
})
t.Run("Success-Nat-Enabled", func(t *testing.T) {
@ -113,7 +113,7 @@ func TestDeleteEgressGateway(t *testing.T) {
t.Run("BadNode", func(t *testing.T) {
node, err := logic.DeleteEgressGateway(gateway.NetID, "01:02:03")
assert.EqualError(t, err, "no result found")
assert.Equal(t, models.Node{}, node)
assert.Equal(t, models.LegacyNode{}, node)
deleteAllNodes()
})
}
@ -136,7 +136,7 @@ func TestGetNetworkNodes(t *testing.T) {
createTestNode()
node, err := logic.GetNetworkNodes("skynet")
assert.Nil(t, err)
assert.NotEqual(t, []models.Node(nil), node)
assert.NotEqual(t, []models.LegacyNode(nil), node)
})
}
@ -147,7 +147,7 @@ func TestUncordonNode(t *testing.T) {
node := createTestNode()
t.Run("BadID", func(t *testing.T) {
resp, err := logic.UncordonNode("blahblah")
assert.Equal(t, models.Node{}, resp)
assert.Equal(t, models.LegacyNode{}, resp)
assert.EqualError(t, err, "no result found")
})
t.Run("Success", func(t *testing.T) {
@ -181,8 +181,8 @@ func TestValidateEgressGateway(t *testing.T) {
func TestNodeACLs(t *testing.T) {
deleteAllNodes()
node1 := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.50", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "linux"}
node2 := models.Node{PublicKey: "DM5qhLAE20FG7BbfBCger+Ac9D2NDOwCtY1rbYDXf14=", Name: "testnode", Endpoint: "10.0.0.100", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet", OS: "linux"}
node1 := models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.50", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "linux"}
node2 := models.LegacyNode{PublicKey: "DM5qhLAE20FG7BbfBCger+Ac9D2NDOwCtY1rbYDXf14=", Name: "testnode", Endpoint: "10.0.0.100", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet", OS: "linux"}
logic.CreateNode(&node1)
logic.CreateNode(&node2)
t.Run("acls not present", func(t *testing.T) {
@ -222,7 +222,7 @@ func TestNodeACLs(t *testing.T) {
currentACL.Save(acls.ContainerID(node1.Network))
})
t.Run("node acls correct after add new node not allowed", func(t *testing.T) {
node3 := models.Node{PublicKey: "this-is-not-valid", Name: "testnode3", Endpoint: "10.0.0.100", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet", OS: "linux"}
node3 := models.LegacyNode{PublicKey: "this-is-not-valid", Name: "testnode3", Endpoint: "10.0.0.100", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet", OS: "linux"}
logic.CreateNode(&node3)
var currentACL, err = nodeacls.FetchAllACLs(nodeacls.NetworkID(node3.Network))
assert.Nil(t, err)
@ -249,8 +249,8 @@ func deleteAllNodes() {
database.DeleteAllRecords(database.NODES_TABLE_NAME)
}
func createTestNode() *models.Node {
createnode := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "linux"}
func createTestNode() *models.LegacyNode {
createnode := models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "linux"}
logic.CreateNode(&createnode)
return &createnode
}

2
database/database.go
View file

@ -142,7 +142,7 @@ func createTable(tableName string) error {
// IsJSONString - checks if valid json
func IsJSONString(value string) bool {
var jsonInt interface{}
var nodeInt models.Node
var nodeInt models.LegacyNode
return json.Unmarshal([]byte(value), &jsonInt) == nil || json.Unmarshal([]byte(value), &nodeInt) == nil
}

8
ee/ee_controllers/networkusers.go
View file

@ -34,9 +34,9 @@ type NetworkUserDataMap map[NetworkName]NetworkUserData
// NetworkUserData - data struct for network users
type NetworkUserData struct {
Nodes []models.Node `json:"nodes" bson:"nodes" yaml:"nodes"`
Nodes []models.LegacyNode `json:"nodes" bson:"nodes" yaml:"nodes"`
Clients []models.ExtClient `json:"clients" bson:"clients" yaml:"clients"`
Vpn []models.Node `json:"vpns" bson:"vpns" yaml:"vpns"`
Vpn []models.LegacyNode `json:"vpns" bson:"vpns" yaml:"vpns"`
Networks []models.Network `json:"networks" bson:"networks" yaml:"networks"`
User promodels.NetworkUser `json:"user" bson:"user" yaml:"user"`
}
@ -80,9 +80,9 @@ func getNetworkUserData(w http.ResponseWriter, r *http.Request) {
netID := networks[i].NetID
newData := NetworkUserData{
Nodes: []models.Node{},
Nodes: []models.LegacyNode{},
Clients: []models.ExtClient{},
Vpn: []models.Node{},
Vpn: []models.LegacyNode{},
Networks: []models.Network{},
}
netUser, err := pro.GetNetworkUser(netID, promodels.NetworkUserID(networkUserName))

8
ee/logic/failover.go
View file

@ -7,7 +7,7 @@ import (
)
// SetFailover - finds a suitable failover candidate and sets it
func SetFailover(node *models.Node) error {
func SetFailover(node *models.LegacyNode) error {
failoverNode := determineFailoverCandidate(node)
if failoverNode != nil {
return setFailoverNode(failoverNode, node)
@ -36,7 +36,7 @@ func ResetFailover(network string) error {
// determineFailoverCandidate - returns a list of nodes that
// are suitable for relaying a given node
func determineFailoverCandidate(nodeToBeRelayed *models.Node) *models.Node {
func determineFailoverCandidate(nodeToBeRelayed *models.LegacyNode) *models.LegacyNode {
currentNetworkNodes, err := logic.GetNetworkNodes(nodeToBeRelayed.Network)
if err != nil {
@ -49,7 +49,7 @@ func determineFailoverCandidate(nodeToBeRelayed *models.Node) *models.Node {
}
minLatency := int64(9223372036854775807) // max signed int64 value
var fastestCandidate *models.Node
var fastestCandidate *models.LegacyNode
for i := range currentNetworkNodes {
if currentNetworkNodes[i].ID == nodeToBeRelayed.ID {
continue
@ -67,7 +67,7 @@ func determineFailoverCandidate(nodeToBeRelayed *models.Node) *models.Node {
}
// setFailoverNode - changes node's failover node
func setFailoverNode(failoverNode, node *models.Node) error {
func setFailoverNode(failoverNode, node *models.LegacyNode) error {
node.FailoverNode = failoverNode.ID
nodeToUpdate, err := logic.GetNodeByID(node.ID)

2
logic/dns.go
View file

@ -75,7 +75,7 @@ func GetNodeDNS(network string) ([]models.DNSEntry, error) {
for _, value := range collection {
var entry models.DNSEntry
var node models.Node
var node models.LegacyNode
if err = json.Unmarshal([]byte(value), &node); err != nil {
continue
}

4
logic/extpeers.go
View file

@ -11,7 +11,7 @@ import (
)
// GetExtPeersList - gets the ext peers lists
func GetExtPeersList(node *models.Node) ([]models.ExtPeersResponse, error) {
func GetExtPeersList(node *models.LegacyNode) ([]models.ExtPeersResponse, error) {
var peers []models.ExtPeersResponse
records, err := database.FetchRecords(database.EXT_CLIENT_TABLE_NAME)
@ -50,7 +50,7 @@ func GetEgressRangesOnNetwork(client *models.ExtClient) ([]string, error) {
return []string{}, err
}
for _, nodeData := range nodesData {
var currentNode models.Node
var currentNode models.LegacyNode
if err = json.Unmarshal([]byte(nodeData), &currentNode); err != nil {
continue
}

46
logic/gateway.go
View file

@ -14,31 +14,31 @@ import (
)
// CreateEgressGateway - creates an egress gateway
func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, error) {
func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.LegacyNode, error) {
for i, cidr := range gateway.Ranges {
normalized, err := NormalizeCIDR(cidr)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
gateway.Ranges[i] = normalized
}
node, err := GetNodeByID(gateway.NodeID)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
if node.OS != "linux" && node.OS != "freebsd" { // add in darwin later
return models.Node{}, errors.New(node.OS + " is unsupported for egress gateways")
return models.LegacyNode{}, errors.New(node.OS + " is unsupported for egress gateways")
}
if node.OS == "linux" && node.FirewallInUse == models.FIREWALL_NONE {
return models.Node{}, errors.New("firewall is not supported for egress gateways")
return models.LegacyNode{}, errors.New("firewall is not supported for egress gateways")
}
if gateway.NatEnabled == "" {
gateway.NatEnabled = "yes"
}
err = ValidateEgressGateway(gateway)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
node.IsEgressGateway = "yes"
node.EgressGatewayRanges = gateway.Ranges
@ -109,7 +109,7 @@ func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, erro
return node, err
}
if err = database.Insert(node.ID, string(nodeData), database.NODES_TABLE_NAME); err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
return node, nil
}
@ -130,11 +130,11 @@ func ValidateEgressGateway(gateway models.EgressGatewayRequest) error {
}
// DeleteEgressGateway - deletes egress from node
func DeleteEgressGateway(network, nodeid string) (models.Node, error) {
func DeleteEgressGateway(network, nodeid string) (models.LegacyNode, error) {
node, err := GetNodeByID(nodeid)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
node.IsEgressGateway = "no"
@ -168,31 +168,31 @@ func DeleteEgressGateway(network, nodeid string) (models.Node, error) {
data, err := json.Marshal(&node)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
if err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME); err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
return node, nil
}
// CreateIngressGateway - creates an ingress gateway
func CreateIngressGateway(netid string, nodeid string, failover bool) (models.Node, error) {
func CreateIngressGateway(netid string, nodeid string, failover bool) (models.LegacyNode, error) {
var postUpCmd, postDownCmd string
node, err := GetNodeByID(nodeid)
if node.FirewallInUse == models.FIREWALL_NONE {
return models.Node{}, errors.New("firewall is not supported for ingress gateways")
return models.LegacyNode{}, errors.New("firewall is not supported for ingress gateways")
}
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
network, err := GetParentNetwork(netid)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
node.IsIngressGateway = "yes"
cidrs := []string{}
@ -236,30 +236,30 @@ func CreateIngressGateway(netid string, nodeid string, failover bool) (models.No
}
data, err := json.Marshal(&node)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
err = SetNetworkNodesLastModified(netid)
return node, err
}
// DeleteIngressGateway - deletes an ingress gateway
func DeleteIngressGateway(networkName string, nodeid string) (models.Node, bool, error) {
func DeleteIngressGateway(networkName string, nodeid string) (models.LegacyNode, bool, error) {
node, err := GetNodeByID(nodeid)
if err != nil {
return models.Node{}, false, err
return models.LegacyNode{}, false, err
}
network, err := GetParentNetwork(networkName)
if err != nil {
return models.Node{}, false, err
return models.LegacyNode{}, false, err
}
// delete ext clients belonging to ingress gateway
if err = DeleteGatewayExtClients(node.ID, networkName); err != nil {
return models.Node{}, false, err
return models.LegacyNode{}, false, err
}
logger.Log(3, "deleting ingress gateway")
wasFailover := node.Failover == "yes"
@ -286,11 +286,11 @@ func DeleteIngressGateway(networkName string, nodeid string) (models.Node, bool,
data, err := json.Marshal(&node)
if err != nil {
return models.Node{}, false, err
return models.LegacyNode{}, false, err
}
err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
if err != nil {
return models.Node{}, wasFailover, err
return models.LegacyNode{}, wasFailover, err
}
err = SetNetworkNodesLastModified(networkName)
return node, wasFailover, err

4
logic/metrics.go
View file

@ -40,10 +40,10 @@ func DeleteMetrics(nodeid string) error {
}
// CollectServerMetrics - collects metrics for given server node
func CollectServerMetrics(serverID string, networkNodes []models.Node) *models.Metrics {
func CollectServerMetrics(serverID string, networkNodes []models.LegacyNode) *models.Metrics {
newServerMetrics := models.Metrics{}
newServerMetrics.Connectivity = make(map[string]models.Metric)
var serverNode models.Node
var serverNode models.LegacyNode
for i := range networkNodes {
currNodeID := networkNodes[i].ID
if currNodeID == serverID {

2
logic/metrics/metrics.go
View file

@ -90,7 +90,7 @@ func Collect(iface, network string, proxy bool, peerMap models.PeerMap) (*models
}
// GetExchangedBytesForNode - get exchanged bytes for current node peers
func GetExchangedBytesForNode(node *models.Node, metrics *models.Metrics) error {
func GetExchangedBytesForNode(node *models.LegacyNode, metrics *models.Metrics) error {
peers, err := logic.GetPeerUpdate(node)
if err != nil {

16
logic/networks.go
View file

@ -135,7 +135,7 @@ func GetNetworkNonServerNodeCount(networkName string) (int, error) {
return count, err
}
for _, value := range collection {
var node models.Node
var node models.LegacyNode
if err = json.Unmarshal([]byte(value), &node); err != nil {
return count, err
} else {
@ -231,7 +231,7 @@ func IsIPUnique(network string, ip string, tableName string, isIpv6 bool) bool {
}
for _, value := range collection { // filter
var node models.Node
var node models.LegacyNode
if err = json.Unmarshal([]byte(value), &node); err != nil {
continue
}
@ -295,7 +295,7 @@ func UniqueAddress6(networkName string, reverse bool) (string, error) {
}
// GetLocalIP - gets the local ip
func GetLocalIP(node models.Node) string {
func GetLocalIP(node models.LegacyNode) string {
var local string
@ -361,7 +361,7 @@ func UpdateNetworkLocalAddresses(networkName string) error {
for _, value := range collection {
var node models.Node
var node models.LegacyNode
err := json.Unmarshal([]byte(value), &node)
if err != nil {
@ -426,7 +426,7 @@ func RemoveNetworkNodeIPv6Addresses(networkName string) error {
for _, value := range collections {
var node models.Node
var node models.LegacyNode
err := json.Unmarshal([]byte(value), &node)
if err != nil {
fmt.Println("error in node address assignment!")
@ -455,7 +455,7 @@ func UpdateNetworkNodeAddresses(networkName string) error {
for _, value := range collections {
var node models.Node
var node models.LegacyNode
err := json.Unmarshal([]byte(value), &node)
if err != nil {
logger.Log(1, "error in node ipv4 address assignment!")
@ -496,7 +496,7 @@ func UpdateNetworkNodeAddresses6(networkName string) error {
for _, value := range collections {
var node models.Node
var node models.LegacyNode
err := json.Unmarshal([]byte(value), &node)
if err != nil {
logger.Log(1, "error in node ipv6 address assignment!")
@ -687,7 +687,7 @@ func networkNodesUpdateAction(networkName string, action string) error {
}
for _, value := range collections {
var node models.Node
var node models.LegacyNode
err := json.Unmarshal([]byte(value), &node)
if err != nil {
fmt.Println("error in node address assignment!")

132
logic/nodes.go
View file

@ -33,11 +33,11 @@ const (
)
// GetNetworkNodes - gets the nodes of a network
func GetNetworkNodes(network string) ([]models.Node, error) {
var nodes []models.Node
func GetNetworkNodes(network string) ([]models.LegacyNode, error) {
var nodes []models.LegacyNode
allnodes, err := GetAllNodes()
if err != nil {
return []models.Node{}, err
return []models.LegacyNode{}, err
}
for _, node := range allnodes {
if node.Network == network {
@ -48,18 +48,18 @@ func GetNetworkNodes(network string) ([]models.Node, error) {
}
// GetSortedNetworkServerNodes - gets nodes of a network, except sorted by update time
func GetSortedNetworkServerNodes(network string) ([]models.Node, error) {
var nodes []models.Node
func GetSortedNetworkServerNodes(network string) ([]models.LegacyNode, error) {
var nodes []models.LegacyNode
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
if database.IsEmptyRecord(err) {
return []models.Node{}, nil
return []models.LegacyNode{}, nil
}
return nodes, err
}
for _, value := range collection {
var node models.Node
var node models.LegacyNode
err := json.Unmarshal([]byte(value), &node)
if err != nil {
continue
@ -73,8 +73,8 @@ func GetSortedNetworkServerNodes(network string) ([]models.Node, error) {
}
// GetServerNodes - gets the server nodes of a network
func GetServerNodes(network string) []models.Node {
var serverNodes = make([]models.Node, 0)
func GetServerNodes(network string) []models.LegacyNode {
var serverNodes = make([]models.LegacyNode, 0)
var nodes, err = GetNetworkNodes(network)
if err != nil {
return serverNodes
@ -88,10 +88,10 @@ func GetServerNodes(network string) []models.Node {
}
// UncordonNode - approves a node to join a network
func UncordonNode(nodeid string) (models.Node, error) {
func UncordonNode(nodeid string) (models.LegacyNode, error) {
node, err := GetNodeByID(nodeid)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
node.SetLastModified()
node.IsPending = "no"
@ -105,14 +105,14 @@ func UncordonNode(nodeid string) (models.Node, error) {
}
// SetIfLeader - gets the peers of a given server node
func SetPeersIfLeader(node *models.Node) {
func SetPeersIfLeader(node *models.LegacyNode) {
if IsLeader(node) {
setNetworkServerPeers(node)
}
}
// IsLeader - determines if a given server node is a leader
func IsLeader(node *models.Node) bool {
func IsLeader(node *models.LegacyNode) bool {
nodes, err := GetSortedNetworkServerNodes(node.Network)
if err != nil {
logger.Log(0, "ERROR: COULD NOT RETRIEVE SERVER NODES. THIS WILL BREAK HOLE PUNCHING.")
@ -129,7 +129,7 @@ func IsLeader(node *models.Node) bool {
// == DB related functions ==
// UpdateNode - takes a node and updates another node with it's values
func UpdateNode(currentNode *models.Node, newNode *models.Node) error {
func UpdateNode(currentNode *models.LegacyNode, newNode *models.LegacyNode) error {
if newNode.Address != currentNode.Address {
if network, err := GetParentNetwork(newNode.Network); err == nil {
if !IsAddressInCIDR(newNode.Address, network.AddressRange) {
@ -168,7 +168,7 @@ func UpdateNode(currentNode *models.Node, newNode *models.Node) error {
}
// DeleteNode - marks node for deletion if called by UI or deletes node if called by node
func DeleteNode(node *models.Node, purge bool) error {
func DeleteNode(node *models.LegacyNode, purge bool) error {
if !purge {
newnode := node
newnode.PendingDelete = true
@ -191,7 +191,7 @@ func DeleteNode(node *models.Node, purge bool) error {
}
// DeleteNodeByID - deletes a node from database
func DeleteNodeByID(node *models.Node) error {
func DeleteNodeByID(node *models.LegacyNode) error {
var err error
var key = node.ID
//delete any ext clients as required
@ -230,13 +230,13 @@ func DeleteNodeByID(node *models.Node) error {
}
// IsNodeIDUnique - checks if node id is unique
func IsNodeIDUnique(node *models.Node) (bool, error) {
func IsNodeIDUnique(node *models.LegacyNode) (bool, error) {
_, err := database.FetchRecord(database.NODES_TABLE_NAME, node.ID)
return database.IsEmptyRecord(err), err
}
// ValidateNode - validates node values
func ValidateNode(node *models.Node, isUpdate bool) error {
func ValidateNode(node *models.LegacyNode, isUpdate bool) error {
v := validator.New()
_ = v.RegisterValidation("id_unique", func(fl validator.FieldLevel) bool {
if isUpdate {
@ -279,7 +279,7 @@ func IsFailoverPresent(network string) bool {
}
// CreateNode - creates a node in database
func CreateNode(node *models.Node) error {
func CreateNode(node *models.LegacyNode) error {
//encrypt that password so we never see it
hash, err := bcrypt.GenerateFromPassword([]byte(node.Password), 5)
@ -387,21 +387,21 @@ func CreateNode(node *models.Node) error {
}
// GetAllNodes - returns all nodes in the DB
func GetAllNodes() ([]models.Node, error) {
var nodes []models.Node
func GetAllNodes() ([]models.LegacyNode, error) {
var nodes []models.LegacyNode
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
if database.IsEmptyRecord(err) {
return []models.Node{}, nil
return []models.LegacyNode{}, nil
}
return []models.Node{}, err
return []models.LegacyNode{}, err
}
for _, value := range collection {
var node models.Node
var node models.LegacyNode
if err := json.Unmarshal([]byte(value), &node); err != nil {
return []models.Node{}, err
return []models.LegacyNode{}, err
}
// add node to our array
nodes = append(nodes, node)
@ -411,13 +411,13 @@ func GetAllNodes() ([]models.Node, error) {
}
// CheckIsServer - check if a node is the server node
func CheckIsServer(node *models.Node) bool {
func CheckIsServer(node *models.LegacyNode) bool {
nodeData, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil && !database.IsEmptyRecord(err) {
return false
}
for _, value := range nodeData {
var tmpNode models.Node
var tmpNode models.LegacyNode
if err := json.Unmarshal([]byte(value), &tmpNode); err != nil {
continue
}
@ -443,7 +443,7 @@ func GetNetworkByNode(node *models.Node) (models.Network, error) {
}
// SetNodeDefaults - sets the defaults of a node to avoid empty fields
func SetNodeDefaults(node *models.Node) {
func SetNodeDefaults(node *models.LegacyNode) {
//TODO: Maybe I should make Network a part of the node struct. Then we can just query the Network object for stuff.
parentNetwork, _ := GetNetworkByNode(node)
@ -524,9 +524,9 @@ func GetRecordKey(id string, network string) (string, error) {
}
// GetNodeByMacAddress - gets a node by mac address
func GetNodeByMacAddress(network string, macaddress string) (models.Node, error) {
func GetNodeByMacAddress(network string, macaddress string) (models.LegacyNode, error) {
var node models.Node
var node models.LegacyNode
key, err := GetRecordKey(macaddress, network)
if err != nil {
@ -535,11 +535,11 @@ func GetNodeByMacAddress(network string, macaddress string) (models.Node, error)
record, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
SetNodeDefaults(&node)
@ -548,11 +548,11 @@ func GetNodeByMacAddress(network string, macaddress string) (models.Node, error)
}
// GetNodesByAddress - gets a node by mac address
func GetNodesByAddress(network string, addresses []string) ([]models.Node, error) {
var nodes []models.Node
func GetNodesByAddress(network string, addresses []string) ([]models.LegacyNode, error) {
var nodes []models.LegacyNode
allnodes, err := GetAllNodes()
if err != nil {
return []models.Node{}, err
return []models.LegacyNode{}, err
}
for _, node := range allnodes {
if node.Network == network && ncutils.StringSliceContains(addresses, node.Address) {
@ -563,9 +563,9 @@ func GetNodesByAddress(network string, addresses []string) ([]models.Node, error
}
// GetDeletedNodeByMacAddress - get a deleted node
func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node, error) {
func GetDeletedNodeByMacAddress(network string, macaddress string) (models.LegacyNode, error) {
var node models.Node
var node models.LegacyNode
key, err := GetRecordKey(macaddress, network)
if err != nil {
@ -574,11 +574,11 @@ func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node,
record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
SetNodeDefaults(&node)
@ -587,9 +587,9 @@ func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node,
}
// GetNodeRelay - gets the relay node of a given network
func GetNodeRelay(network string, relayedNodeAddr string) (models.Node, error) {
func GetNodeRelay(network string, relayedNodeAddr string) (models.LegacyNode, error) {
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
var relay models.Node
var relay models.LegacyNode
if err != nil {
if database.IsEmptyRecord(err) {
return relay, nil
@ -614,30 +614,30 @@ func GetNodeRelay(network string, relayedNodeAddr string) (models.Node, error) {
return relay, errors.New(RELAY_NODE_ERR + " " + relayedNodeAddr)
}
func GetNodeByID(uuid string) (models.Node, error) {
func GetNodeByID(uuid string) (models.LegacyNode, error) {
var record, err = database.FetchRecord(database.NODES_TABLE_NAME, uuid)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
var node models.Node
var node models.LegacyNode
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
return node, nil
}
// GetDeletedNodeByID - get a deleted node
func GetDeletedNodeByID(uuid string) (models.Node, error) {
func GetDeletedNodeByID(uuid string) (models.LegacyNode, error) {
var node models.Node
var node models.LegacyNode
record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, uuid)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
SetNodeDefaults(&node)
@ -646,39 +646,39 @@ func GetDeletedNodeByID(uuid string) (models.Node, error) {
}
// GetNetworkServerNodeID - get network server node ID if exists
func GetNetworkServerLeader(network string) (models.Node, error) {
func GetNetworkServerLeader(network string) (models.LegacyNode, error) {
nodes, err := GetSortedNetworkServerNodes(network)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
for _, node := range nodes {
if IsLeader(&node) {
return node, nil
}
}
return models.Node{}, errors.New("could not find server leader")
return models.LegacyNode{}, errors.New("could not find server leader")
}
// GetNetworkServerNodeID - get network server node ID if exists
func GetNetworkServerLocal(network string) (models.Node, error) {
func GetNetworkServerLocal(network string) (models.LegacyNode, error) {
nodes, err := GetSortedNetworkServerNodes(network)
if err != nil {
return models.Node{}, err
return models.LegacyNode{}, err
}
mac := servercfg.GetNodeID()
if mac == "" {
return models.Node{}, fmt.Errorf("error retrieving local server node: server node ID is unset")
return models.LegacyNode{}, fmt.Errorf("error retrieving local server node: server node ID is unset")
}
for _, node := range nodes {
if mac == node.MacAddress {
return node, nil
}
}
return models.Node{}, errors.New("could not find node for local server")
return models.LegacyNode{}, errors.New("could not find node for local server")
}
// IsLocalServer - get network server node ID if exists
func IsLocalServer(node *models.Node) bool {
func IsLocalServer(node *models.LegacyNode) bool {
var islocal bool
local, err := GetNetworkServerLocal(node.Network)
if err != nil {
@ -688,15 +688,15 @@ func IsLocalServer(node *models.Node) bool {
}
// validateServer - make sure servers dont change port or address
func validateServer(currentNode, newNode *models.Node) bool {
func validateServer(currentNode, newNode *models.LegacyNode) bool {
return (newNode.Address == currentNode.Address &&
newNode.ListenPort == currentNode.ListenPort &&
newNode.IsServer == "yes")
}
// unsetHub - unset hub on network nodes
func UnsetHub(networkName string) (*models.Node, error) {
var nodesToUpdate models.Node
func UnsetHub(networkName string) (*models.LegacyNode, error) {
var nodesToUpdate models.LegacyNode
nodes, err := GetNetworkNodes(networkName)
if err != nil {
return &nodesToUpdate, err
@ -718,7 +718,7 @@ func UnsetHub(networkName string) (*models.Node, error) {
}
// FindRelay - returns the node that is the relay for a relayed node
func FindRelay(node *models.Node) *models.Node {
func FindRelay(node *models.LegacyNode) *models.LegacyNode {
if node.IsRelayed == "no" {
return nil
}
@ -739,7 +739,7 @@ func FindRelay(node *models.Node) *models.Node {
return nil
}
func findNode(ip string) (*models.Node, error) {
func findNode(ip string) (*models.LegacyNode, error) {
nodes, err := GetAllNodes()
if err != nil {
return nil, err
@ -756,11 +756,11 @@ func findNode(ip string) (*models.Node, error) {
}
// GetNetworkIngresses - gets the gateways of a network
func GetNetworkIngresses(network string) ([]models.Node, error) {
var ingresses []models.Node
func GetNetworkIngresses(network string) ([]models.LegacyNode, error) {
var ingresses []models.LegacyNode
netNodes, err := GetNetworkNodes(network)
if err != nil {
return []models.Node{}, err
return []models.LegacyNode{}, err
}
for i := range netNodes {
if netNodes[i].IsIngressGateway == "yes" {
@ -772,7 +772,7 @@ func GetNetworkIngresses(network string) ([]models.Node, error) {
// == PRO ==
func updateProNodeACLS(node *models.Node) error {
func updateProNodeACLS(node *models.LegacyNode) error {
// == PRO node ACLs ==
networkNodes, err := GetNetworkNodes(node.Network)
if err != nil {

16
logic/peers.go
View file

@ -21,7 +21,7 @@ import (
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
)
func GetPeersForProxy(node *models.Node, onlyPeers bool) (manager.ProxyManagerPayload, error) {
func GetPeersForProxy(node *models.LegacyNode, onlyPeers bool) (manager.ProxyManagerPayload, error) {
proxyPayload := manager.ProxyManagerPayload{}
var peers []wgtypes.PeerConfig
peerConfMap := make(map[string]proxy_models.PeerConf)
@ -167,7 +167,7 @@ func GetPeersForProxy(node *models.Node, onlyPeers bool) (manager.ProxyManagerPa
}
// GetPeerUpdate - gets a wireguard peer config for each peer of a node
func GetPeerUpdate(node *models.Node) (models.PeerUpdate, error) {
func GetPeerUpdate(node *models.LegacyNode) (models.PeerUpdate, error) {
var peerUpdate models.PeerUpdate
var peers []wgtypes.PeerConfig
var serverNodeAddresses = []models.ServerAddr{}
@ -349,7 +349,7 @@ func GetPeerUpdate(node *models.Node) (models.PeerUpdate, error) {
return peerUpdate, nil
}
func getExtPeers(node *models.Node, forIngressNode bool) ([]wgtypes.PeerConfig, []models.IDandAddr, error) {
func getExtPeers(node *models.LegacyNode, forIngressNode bool) ([]wgtypes.PeerConfig, []models.IDandAddr, error) {
var peers []wgtypes.PeerConfig
var idsAndAddr []models.IDandAddr
extPeers, err := GetNetworkExtClients(node.Network)
@ -428,7 +428,7 @@ func getExtPeers(node *models.Node, forIngressNode bool) ([]wgtypes.PeerConfig,
}
func getExtPeersForProxy(node *models.Node, proxyPeerConf map[string]proxy_models.PeerConf) ([]wgtypes.PeerConfig, map[string]proxy_models.PeerConf, error) {
func getExtPeersForProxy(node *models.LegacyNode, proxyPeerConf map[string]proxy_models.PeerConf) ([]wgtypes.PeerConfig, map[string]proxy_models.PeerConf, error) {
var peers []wgtypes.PeerConfig
extPeers, err := GetNetworkExtClients(node.Network)
@ -499,7 +499,7 @@ func getExtPeersForProxy(node *models.Node, proxyPeerConf map[string]proxy_model
}
// GetAllowedIPs - calculates the wireguard allowedip field for a peer of a node based on the peer and node settings
func GetAllowedIPs(node, peer *models.Node, metrics *models.Metrics, fetchRelayedIps bool) []net.IPNet {
func GetAllowedIPs(node, peer *models.LegacyNode, metrics *models.Metrics, fetchRelayedIps bool) []net.IPNet {
var allowedips []net.IPNet
allowedips = getNodeAllowedIPs(peer, node)
@ -611,7 +611,7 @@ func getPeerDNS(network string) string {
// GetPeerUpdateForRelayedNode - calculates peer update for a relayed node by getting the relay
// copying the relay node's allowed ips and making appropriate substitutions
func GetPeerUpdateForRelayedNode(node *models.Node, udppeers map[string]string) (models.PeerUpdate, error) {
func GetPeerUpdateForRelayedNode(node *models.LegacyNode, udppeers map[string]string) (models.PeerUpdate, error) {
var peerUpdate models.PeerUpdate
var peers []wgtypes.PeerConfig
var serverNodeAddresses = []models.ServerAddr{}
@ -757,7 +757,7 @@ func GetPeerUpdateForRelayedNode(node *models.Node, udppeers map[string]string)
return peerUpdate, nil
}
func getEgressIPs(node, peer *models.Node) []net.IPNet {
func getEgressIPs(node, peer *models.LegacyNode) []net.IPNet {
//check for internet gateway
internetGateway := false
if slices.Contains(peer.EgressGatewayRanges, "0.0.0.0/0") || slices.Contains(peer.EgressGatewayRanges, "::/0") {
@ -789,7 +789,7 @@ func getEgressIPs(node, peer *models.Node) []net.IPNet {
return allowedips
}
func getNodeAllowedIPs(peer, node *models.Node) []net.IPNet {
func getNodeAllowedIPs(peer, node *models.LegacyNode) []net.IPNet {
var allowedips = []net.IPNet{}
if peer.Address != "" {

2
logic/pro/networkuser.go
View file

@ -175,7 +175,7 @@ func RemoveAllNetworkUsers(network string) error {
// IsUserNodeAllowed - given a list of nodes, determine if the user's node is allowed based on ID
// Checks if node is in given nodes list as well as being in user's list
func IsUserNodeAllowed(nodes []models.Node, network, userID, nodeID string) bool {
func IsUserNodeAllowed(nodes []models.LegacyNode, network, userID, nodeID string) bool {
netUser, err := GetNetworkUser(network, promodels.NetworkUserID(userID))
if err != nil {

4
logic/pro/networkuser_test.go
View file

@ -18,8 +18,8 @@ func TestNetworkUserLogic(t *testing.T) {
NetID: "skynet",
AddressRange: "192.168.0.0/24",
}
nodes := []models.Node{
models.Node{ID: "coolnode"},
nodes := []models.LegacyNode{
models.LegacyNode{ID: "coolnode"},
}
clients := []models.ExtClient{

2
logic/pro/proacls/nodes.go
View file

@ -7,7 +7,7 @@ import (
)
// AdjustNodeAcls - adjusts ACLs based on a node's default value
func AdjustNodeAcls(node *models.Node, networkNodes []models.Node) error {
func AdjustNodeAcls(node *models.LegacyNode, networkNodes []models.LegacyNode) error {
networkID := nodeacls.NetworkID(node.Network)
nodeID := nodeacls.NodeID(node.ID)
currentACLs, err := nodeacls.FetchAllACLs(networkID)

34
logic/relay.go
View file

@ -12,19 +12,19 @@ import (
)
// CreateRelay - creates a relay
func CreateRelay(relay models.RelayRequest) ([]models.Node, models.Node, error) {
var returnnodes []models.Node
func CreateRelay(relay models.RelayRequest) ([]models.LegacyNode, models.LegacyNode, error) {
var returnnodes []models.LegacyNode
node, err := GetNodeByID(relay.NodeID)
if err != nil {
return returnnodes, models.Node{}, err
return returnnodes, models.LegacyNode{}, err
}
if node.OS != "linux" {
return returnnodes, models.Node{}, fmt.Errorf("only linux machines can be relay nodes")
return returnnodes, models.LegacyNode{}, fmt.Errorf("only linux machines can be relay nodes")
}
err = ValidateRelay(relay)
if err != nil {
return returnnodes, models.Node{}, err
return returnnodes, models.LegacyNode{}, err
}
node.IsRelay = "yes"
node.RelayAddrs = relay.RelayAddrs
@ -35,7 +35,7 @@ func CreateRelay(relay models.RelayRequest) ([]models.Node, models.Node, error)
return returnnodes, node, err
}
if err = database.Insert(node.ID, string(nodeData), database.NODES_TABLE_NAME); err != nil {
return returnnodes, models.Node{}, err
return returnnodes, models.LegacyNode{}, err
}
returnnodes, err = SetRelayedNodes(true, node.Network, node.RelayAddrs)
if err != nil {
@ -45,8 +45,8 @@ func CreateRelay(relay models.RelayRequest) ([]models.Node, models.Node, error)
}
// SetRelayedNodes- set relayed nodes
func SetRelayedNodes(setRelayed bool, networkName string, addrs []string) ([]models.Node, error) {
var returnnodes []models.Node
func SetRelayedNodes(setRelayed bool, networkName string, addrs []string) ([]models.LegacyNode, error) {
var returnnodes []models.LegacyNode
networkNodes, err := GetNetworkNodes(networkName)
if err != nil {
return returnnodes, err
@ -72,8 +72,8 @@ func SetRelayedNodes(setRelayed bool, networkName string, addrs []string) ([]mod
}
return returnnodes, nil
}
func GetRelayedNodes(relayNode *models.Node) ([]models.Node, error) {
var returnnodes []models.Node
func GetRelayedNodes(relayNode *models.LegacyNode) ([]models.LegacyNode, error) {
var returnnodes []models.LegacyNode
networkNodes, err := GetNetworkNodes(relayNode.Network)
if err != nil {
return returnnodes, err
@ -102,8 +102,8 @@ func ValidateRelay(relay models.RelayRequest) error {
}
// UpdateRelay - updates a relay
func UpdateRelay(network string, oldAddrs []string, newAddrs []string) []models.Node {
var returnnodes []models.Node
func UpdateRelay(network string, oldAddrs []string, newAddrs []string) []models.LegacyNode {
var returnnodes []models.LegacyNode
time.Sleep(time.Second / 4)
_, err := SetRelayedNodes(false, network, oldAddrs)
if err != nil {
@ -117,11 +117,11 @@ func UpdateRelay(network string, oldAddrs []string, newAddrs []string) []models.
}
// DeleteRelay - deletes a relay
func DeleteRelay(network, nodeid string) ([]models.Node, models.Node, error) {
var returnnodes []models.Node
func DeleteRelay(network, nodeid string) ([]models.LegacyNode, models.LegacyNode, error) {
var returnnodes []models.LegacyNode
node, err := GetNodeByID(nodeid)
if err != nil {
return returnnodes, models.Node{}, err
return returnnodes, models.LegacyNode{}, err
}
returnnodes, err = SetRelayedNodes(false, node.Network, node.RelayAddrs)
if err != nil {
@ -134,10 +134,10 @@ func DeleteRelay(network, nodeid string) ([]models.Node, models.Node, error) {
data, err := json.Marshal(&node)
if err != nil {
return returnnodes, models.Node{}, err
return returnnodes, models.LegacyNode{}, err
}
if err = database.Insert(nodeid, string(data), database.NODES_TABLE_NAME); err != nil {
return returnnodes, models.Node{}, err
return returnnodes, models.LegacyNode{}, err
}
return returnnodes, node, nil
}

16
logic/server.go
View file

@ -25,7 +25,7 @@ var ProxyMgmChan = make(chan *manager.ProxyManagerPayload, 100)
var EnterpriseCheckFuncs []func()
// EnterpriseFailoverFunc - interface to control failover funcs
var EnterpriseFailoverFunc func(node *models.Node) error
var EnterpriseFailoverFunc func(node *models.LegacyNode) error
// EnterpriseResetFailoverFunc - interface to control reset failover funcs
var EnterpriseResetFailoverFunc func(network string) error
@ -42,8 +42,8 @@ const KUBERNETES_LISTEN_PORT = 31821
const KUBERNETES_SERVER_MTU = 1024
// ServerJoin - responsible for joining a server to a network
func ServerJoin(networkSettings *models.Network) (models.Node, error) {
var returnNode models.Node
func ServerJoin(networkSettings *models.Network) (models.LegacyNode, error) {
var returnNode models.LegacyNode
if networkSettings == nil || networkSettings.NetID == "" {
return returnNode, errors.New("no network provided")
}
@ -73,7 +73,7 @@ func ServerJoin(networkSettings *models.Network) (models.Node, error) {
}
}
}
var node = &models.Node{
var node = &models.LegacyNode{
IsServer: "yes",
DNSOn: "no",
IsStatic: "yes",
@ -197,7 +197,7 @@ func EnterpriseCheck() {
// ServerUpdate - updates the server
// replaces legacy Checkin code
func ServerUpdate(serverNode *models.Node, ifaceDelta bool) error {
func ServerUpdate(serverNode *models.LegacyNode, ifaceDelta bool) error {
if !IsLocalServer(serverNode) {
logger.Log(1, "skipping server update as not the leader")
return nil
@ -227,7 +227,7 @@ func isDeleteError(err error) bool {
return err != nil && strings.Contains(err.Error(), models.NODE_DELETE)
}
func checkNodeActions(node *models.Node) string {
func checkNodeActions(node *models.LegacyNode) string {
if node.Action == models.NODE_UPDATE_KEY {
err := setWGKeyConfig(node)
if err != nil {
@ -248,7 +248,7 @@ func checkNodeActions(node *models.Node) string {
// == Private ==
// ServerPull - performs a server pull
func ServerPull(serverNode *models.Node, ifaceDelta bool) error {
func ServerPull(serverNode *models.LegacyNode, ifaceDelta bool) error {
if serverNode.IsServer != "yes" {
return fmt.Errorf("attempted pull from non-server node: %s - %s", serverNode.Name, serverNode.ID)
}
@ -313,7 +313,7 @@ func getServerLocalIP(networkSettings *models.Network) (string, error) {
return "", errors.New("could not find a local ip for server")
}
func serverPush(serverNode *models.Node) error {
func serverPush(serverNode *models.LegacyNode) error {
serverNode.OS = runtime.GOOS
serverNode.SetLastCheckIn()
return UpdateNode(serverNode, serverNode)

2
logic/telemetry.go
View file

@ -111,7 +111,7 @@ func setTelemetryTimestamp(telRecord *models.Telemetry) error {
}
// getClientCount - returns counts of nodes with various OS types and conditions
func getClientCount(nodes []models.Node) clientCount {
func getClientCount(nodes []models.LegacyNode) clientCount {
var count clientCount
for _, node := range nodes {
switch node.OS {

4
logic/util.go
View file

@ -147,7 +147,7 @@ func StringSliceContains(slice []string, item string) bool {
// == private ==
// sets the network server peers of a given node
func setNetworkServerPeers(serverNode *models.Node) {
func setNetworkServerPeers(serverNode *models.LegacyNode) {
if currentPeersList, err := getSystemPeers(serverNode); err == nil {
if currentPeersList == nil {
currentPeersList = make(map[string]string)
@ -161,7 +161,7 @@ func setNetworkServerPeers(serverNode *models.Node) {
}
// ShouldPublishPeerPorts - Gets ports from iface, sets, and returns true if they are different
func ShouldPublishPeerPorts(serverNode *models.Node) bool {
func ShouldPublishPeerPorts(serverNode *models.LegacyNode) bool {
if currentPeersList, err := getSystemPeers(serverNode); err == nil {
if database.SetPeers(currentPeersList, serverNode.Network) {
logger.Log(1, "set new peers on network", serverNode.Network)

12
logic/wireguard.go
View file

@ -23,7 +23,7 @@ func RemoveConf(iface string, printlog bool) error {
}
// HasPeerConnected - checks if a client node has connected over WG
func HasPeerConnected(node *models.Node) bool {
func HasPeerConnected(node *models.LegacyNode) bool {
client, err := wgctrl.New()
if err != nil {
return false
@ -44,7 +44,7 @@ func HasPeerConnected(node *models.Node) bool {
}
// IfaceDelta - checks if the new node causes an interface change
func IfaceDelta(currentNode *models.Node, newNode *models.Node) bool {
func IfaceDelta(currentNode *models.LegacyNode, newNode *models.LegacyNode) bool {
// single comparison statements
if newNode.Endpoint != currentNode.Endpoint ||
newNode.PublicKey != currentNode.PublicKey ||
@ -99,7 +99,7 @@ func IfaceDelta(currentNode *models.Node, newNode *models.Node) bool {
// == Private Functions ==
// gets the server peers locally
func getSystemPeers(node *models.Node) (map[string]string, error) {
func getSystemPeers(node *models.LegacyNode) (map[string]string, error) {
peers := make(map[string]string)
client, err := wgctrl.New()
@ -127,7 +127,7 @@ func removeWGQuickConf(confPath string, printlog bool) error {
return nil
}
func setWGConfig(node *models.Node, peerupdate bool) error {
func setWGConfig(node *models.LegacyNode, peerupdate bool) error {
peers, err := GetPeerUpdate(node)
if err != nil {
return err
@ -174,7 +174,7 @@ func setWGConfig(node *models.Node, peerupdate bool) error {
return nil
}
func setWGKeyConfig(node *models.Node) error {
func setWGKeyConfig(node *models.LegacyNode) error {
privatekey, err := wgtypes.GeneratePrivateKey()
if err != nil {
@ -195,7 +195,7 @@ func setWGKeyConfig(node *models.Node) error {
return setWGConfig(node, false)
}
func removeLocalServer(node *models.Node) error {
func removeLocalServer(node *models.LegacyNode) error {
var err error
var ifacename = node.Interface

2
logic/zombie.go
View file

@ -23,7 +23,7 @@ var (
// CheckZombies - checks if new node has same macaddress as existing node
// if so, existing node is added to zombie node quarantine list
func CheckZombies(newnode *models.Node) {
func CheckZombies(newnode *models.LegacyNode) {
nodes, err := GetNetworkNodes(newnode.Network)
if err != nil {
logger.Log(1, "Failed to retrieve network nodes", newnode.Network, err.Error())

182
models/node.go
View file

@ -7,7 +7,9 @@ import (
"strings"
"time"
"github.com/google/uuid"
"golang.org/x/crypto/bcrypt"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
)
const (
@ -53,8 +55,46 @@ type Iface struct {
AddressString string `json:"addressString"`
}
// Node - struct for node model
// CommonNode - represents a commonn node data elements shared by netmaker and netclient
type CommonNode struct {
ID uuid.UUID `json:"id" yaml:"id"`
Network string `json:"network" yaml:"network"`
NetworkRange net.IPNet `json:"networkrange" yaml:"networkrange"`
NetworkRange6 net.IPNet `json:"networkrange6" yaml:"networkrange6"`
InternetGateway *net.UDPAddr `json:"internetgateway" yaml:"internetgateway"`
Server string `json:"server" yaml:"server"`
Connected bool `json:"connected" yaml:"connected"`
Interfaces []Iface `json:"interfaces" yaml:"interfaces"`
EndpointIP net.IP `json:"endpointip" yaml:"endpointip"`
Address net.IPNet `json:"address" yaml:"address"`
Address6 net.IPNet `json:"address6" yaml:"address6"`
PostUp string `json:"postup" yaml:"postup"`
PostDown string `json:"postdown" yaml:"postdown"`
Action string `json:"action" yaml:"action"`
IsServer bool `json:"isserver" yaml:"isserver"`
IsLocal bool `json:"islocal" yaml:"islocal"`
IsEgressGateway bool `json:"isegressgateway" yaml:"isegressgateway"`
IsIngressGateway bool `json:"isingressgateway" yaml:"isingressgateway"`
IsStatic bool `json:"isstatic" yaml:"isstatic"`
IsPending bool `json:"ispending" yaml:"ispending"`
DNSOn bool `json:"dnson" yaml:"dnson"`
IsHub bool `json:"ishub" yaml:"ishub"`
PersistentKeepalive int `json:"persistentkeepalive" yaml:"persistentkeepalive"`
Peers []wgtypes.PeerConfig `json:"peers" yaml:"peers"`
Proxy bool `json:"proxy" bson:"proxy" yaml:"proxy"`
}
// Node - a model of a network node
type Node struct {
CommonNode
PendingDelete bool `json:"pendingdelete" bson:"pendingdelete" yaml:"pendingdelete"`
// == PRO ==
DefaultACL string `json:"defaultacl,omitempty" bson:"defaultacl,omitempty" yaml:"defaultacl,omitempty" validate:"checkyesornoorunset"`
OwnerID string `json:"ownerid,omitempty" bson:"ownerid,omitempty" yaml:"ownerid,omitempty"`
}
// LegacyNode - legacy struct for node model
type LegacyNode struct {
ID string `json:"id,omitempty" bson:"id,omitempty" yaml:"id,omitempty" validate:"required,min=5,id_unique"`
HostID string `json:"hostid,omitempty" bson:"id,omitempty" yaml:"hostid,omitempty" validate:"required,min=5,id_unique"`
Address string `json:"address" bson:"address" yaml:"address" validate:"omitempty,ipv4"`
@ -122,7 +162,7 @@ type Node struct {
}
// NodesArray - used for node sorting
type NodesArray []Node
type NodesArray []LegacyNode
// NodesArray.Len - gets length of node array
func (a NodesArray) Len() int { return len(a) }
@ -140,7 +180,7 @@ func isLess(ipA string, ipB string) bool {
}
// Node.PrimaryAddress - return ipv4 address if present, else return ipv6
func (node *Node) PrimaryAddress() string {
func (node *LegacyNode) PrimaryAddress() string {
if node.Address != "" {
return node.Address
}
@ -148,7 +188,7 @@ func (node *Node) PrimaryAddress() string {
}
// Node.SetDefaultConnected
func (node *Node) SetDefaultConnected() {
func (node *LegacyNode) SetDefaultConnected() {
if node.Connected == "" {
node.Connected = "yes"
}
@ -158,84 +198,84 @@ func (node *Node) SetDefaultConnected() {
}
// Node.SetDefaultACL
func (node *Node) SetDefaultACL() {
func (node *LegacyNode) SetDefaultACL() {
if node.DefaultACL == "" {
node.DefaultACL = "yes"
}
}
// Node.SetDefaultMTU - sets default MTU of a node
func (node *Node) SetDefaultMTU() {
func (node *LegacyNode) SetDefaultMTU() {
if node.MTU == 0 {
node.MTU = 1280
}
}
// Node.SetDefaultNFTablesPresent - sets default for nftables check
func (node *Node) SetDefaultNFTablesPresent() {
func (node *LegacyNode) SetDefaultNFTablesPresent() {
if node.FirewallInUse == "" {
node.FirewallInUse = FIREWALL_IPTABLES // default to iptables
}
}
// Node.SetDefaulIsPending - sets ispending default
func (node *Node) SetDefaulIsPending() {
func (node *LegacyNode) SetDefaulIsPending() {
if node.IsPending == "" {
node.IsPending = "no"
}
}
// Node.SetDefaultIsRelayed - set default is relayed
func (node *Node) SetDefaultIsRelayed() {
func (node *LegacyNode) SetDefaultIsRelayed() {
if node.IsRelayed == "" {
node.IsRelayed = "no"
}
}
// Node.SetDefaultIsRelayed - set default is relayed
func (node *Node) SetDefaultIsHub() {
func (node *LegacyNode) SetDefaultIsHub() {
if node.IsHub == "" {
node.IsHub = "no"
}
}
// Node.SetDefaultIsRelay - set default isrelay
func (node *Node) SetDefaultIsRelay() {
func (node *LegacyNode) SetDefaultIsRelay() {
if node.IsRelay == "" {
node.IsRelay = "no"
}
}
// Node.SetDefaultIsDocker - set default isdocker
func (node *Node) SetDefaultIsDocker() {
func (node *LegacyNode) SetDefaultIsDocker() {
if node.IsDocker == "" {
node.IsDocker = "no"
}
}
// Node.SetDefaultIsK8S - set default isk8s
func (node *Node) SetDefaultIsK8S() {
func (node *LegacyNode) SetDefaultIsK8S() {
if node.IsK8S == "" {
node.IsK8S = "no"
}
}
// Node.SetDefaultEgressGateway - sets default egress gateway status
func (node *Node) SetDefaultEgressGateway() {
func (node *LegacyNode) SetDefaultEgressGateway() {
if node.IsEgressGateway == "" {
node.IsEgressGateway = "no"
}
}
// Node.SetDefaultIngressGateway - sets default ingress gateway status
func (node *Node) SetDefaultIngressGateway() {
func (node *LegacyNode) SetDefaultIngressGateway() {
if node.IsIngressGateway == "" {
node.IsIngressGateway = "no"
}
}
// Node.SetDefaultAction - sets default action status
func (node *Node) SetDefaultAction() {
func (node *LegacyNode) SetDefaultAction() {
if node.Action == "" {
node.Action = NODE_NOOP
}
@ -249,35 +289,35 @@ func (node *Node) SetDefaultAction() {
//}
// Node.SetIPForwardingDefault - set ip forwarding default
func (node *Node) SetIPForwardingDefault() {
func (node *LegacyNode) SetIPForwardingDefault() {
if node.IPForwarding == "" {
node.IPForwarding = "yes"
}
}
// Node.SetIsLocalDefault - set is local default
func (node *Node) SetIsLocalDefault() {
func (node *LegacyNode) SetIsLocalDefault() {
if node.IsLocal == "" {
node.IsLocal = "no"
}
}
// Node.SetDNSOnDefault - sets dns on default
func (node *Node) SetDNSOnDefault() {
func (node *LegacyNode) SetDNSOnDefault() {
if node.DNSOn == "" {
node.DNSOn = "yes"
}
}
// Node.SetIsServerDefault - sets node isserver default
func (node *Node) SetIsServerDefault() {
func (node *LegacyNode) SetIsServerDefault() {
if node.IsServer != "yes" {
node.IsServer = "no"
}
}
// Node.SetIsStaticDefault - set is static default
func (node *Node) SetIsStaticDefault() {
func (node *LegacyNode) SetIsStaticDefault() {
if node.IsServer == "yes" {
node.IsStatic = "yes"
} else if node.IsStatic != "yes" {
@ -286,41 +326,41 @@ func (node *Node) SetIsStaticDefault() {
}
// Node.SetLastModified - set last modified initial time
func (node *Node) SetLastModified() {
func (node *LegacyNode) SetLastModified() {
node.LastModified = time.Now().Unix()
}
// Node.SetLastCheckIn - time.Now().Unix()
func (node *Node) SetLastCheckIn() {
func (node *LegacyNode) SetLastCheckIn() {
node.LastCheckIn = time.Now().Unix()
}
// Node.SetLastPeerUpdate - sets last peer update time
func (node *Node) SetLastPeerUpdate() {
func (node *LegacyNode) SetLastPeerUpdate() {
node.LastPeerUpdate = time.Now().Unix()
}
// Node.SetExpirationDateTime - sets node expiry time
func (node *Node) SetExpirationDateTime() {
func (node *LegacyNode) SetExpirationDateTime() {
node.ExpirationDateTime = time.Now().Unix() + TEN_YEARS_IN_SECONDS
}
// Node.SetDefaultName - sets a random name to node
func (node *Node) SetDefaultName() {
func (node *LegacyNode) SetDefaultName() {
if node.Name == "" {
node.Name = GenerateNodeName()
}
}
// Node.SetDefaultFailover - sets default value of failover status to no if not set
func (node *Node) SetDefaultFailover() {
func (node *LegacyNode) SetDefaultFailover() {
if node.Failover == "" {
node.Failover = "no"
}
}
// Node.Fill - fills other node data into calling node data if not set on calling node
func (newNode *Node) Fill(currentNode *Node) { // TODO add new field for nftables present
func (newNode *LegacyNode) Fill(currentNode *LegacyNode) { // TODO add new field for nftables present
newNode.ID = currentNode.ID
if newNode.Address == "" {
@ -498,7 +538,7 @@ func IsIpv4Net(host string) bool {
}
// Node.NameInNodeCharset - returns if name is in charset below or not
func (node *Node) NameInNodeCharSet() bool {
func (node *LegacyNode) NameInNodeCharSet() bool {
charset := "abcdefghijklmnopqrstuvwxyz1234567890-"
@ -513,11 +553,91 @@ func (node *Node) NameInNodeCharSet() bool {
// == PRO ==
// Node.DoesACLAllow - checks if default ACL on node is "yes"
func (node *Node) DoesACLAllow() bool {
func (node *LegacyNode) DoesACLAllow() bool {
return node.DefaultACL == "yes"
}
// Node.DoesACLDeny - checks if default ACL on node is "no"
func (node *Node) DoesACLDeny() bool {
func (node *LegacyNode) DoesACLDeny() bool {
return node.DefaultACL == "no"
}
func (ln *LegacyNode) ConvertToNewNode() (*Host, *Node) {
var node Node
//host:= logic.GetHost(node.HostID)
var host Host
if host.ID.String() == "" {
host.ID = uuid.New()
host.FirewallInUse = ln.FirewallInUse
host.Version = ln.Version
host.IPForwarding = parseBool(ln.IPForwarding)
host.HostPass = ln.Password
host.Name = ln.Name
host.ListenPort = int(ln.ListenPort)
_, cidr, _ := net.ParseCIDR(ln.LocalAddress)
host.LocalAddress = *cidr
_, cidr, _ = net.ParseCIDR(ln.LocalRange)
host.LocalRange = *cidr
host.LocalListenPort = int(ln.LocalListenPort)
host.ProxyListenPort = int(ln.ProxyListenPort)
host.MTU = int(ln.MTU)
host.PublicKey, _ = wgtypes.ParseKey(ln.PublicKey)
host.MacAddress, _ = net.ParseMAC(ln.MacAddress)
host.TrafficKeyPublic = ln.TrafficKeys.Mine
gateway, _ := net.ResolveUDPAddr("udp", ln.InternetGateway)
host.InternetGateway = *gateway
id, _ := uuid.Parse(ln.ID)
host.Nodes = append(host.Nodes, id)
}
id, _ := uuid.Parse(ln.ID)
node.ID = id
node.Network = ln.Network
_, cidr, _ := net.ParseCIDR(ln.NetworkSettings.AddressRange)
node.NetworkRange = *cidr
_, cidr, _ = net.ParseCIDR(ln.NetworkSettings.AddressRange6)
node.NetworkRange6 = *cidr
node.Server = ln.Server
node.Connected = parseBool(ln.Connected)
node.Interfaces = ln.Interfaces
node.EndpointIP = net.ParseIP(ln.Endpoint)
_, cidr, _ = net.ParseCIDR(ln.Address)
node.Address = *cidr
_, cidr, _ = net.ParseCIDR(ln.Address6)
node.Address6 = *cidr
node.PostUp = ln.PostUp
node.PostDown = ln.PostDown
node.Action = ln.Action
node.IsServer = parseBool(ln.IsServer)
node.IsLocal = parseBool(ln.IsLocal)
node.IsEgressGateway = parseBool(ln.IsEgressGateway)
node.IsIngressGateway = parseBool(ln.IsIngressGateway)
node.IsStatic = parseBool(ln.IsStatic)
node.DNSOn = parseBool(ln.DNSOn)
node.PersistentKeepalive = int(ln.PersistentKeepalive)
node.Proxy = ln.Proxy
return &host, &node
}
// Node.NetworkSettings updates a node with network settings
func (node *Node) NetworkSettings(n Network) {
_, cidr, _ := net.ParseCIDR(n.AddressRange)
node.NetworkRange = *cidr
}
func parseBool(s string) bool {
b := false
if s == "yes" {
b = true
}
return b
}
func formatBool(b bool) string {
s := "no"
if b {
s = "yes"
}
return s
}

19
models/structs.go
View file

@ -6,7 +6,6 @@ import (
jwt "github.com/golang-jwt/jwt/v4"
"github.com/gravitl/netclient/nmproxy/manager"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
)
const PLACEHOLDER_KEY_TEXT = "ACCESS_KEY"
@ -176,8 +175,8 @@ type RelayRequest struct {
// ServerUpdateData - contains data to configure server
// and if it should set peers
type ServerUpdateData struct {
UpdatePeers bool `json:"updatepeers" bson:"updatepeers"`
Node Node `json:"servernode" bson:"servernode"`
UpdatePeers bool `json:"updatepeers" bson:"updatepeers"`
Node LegacyNode `json:"servernode" bson:"servernode"`
}
// Telemetry - contains UUID of the server and timestamp of last send to posthog
@ -203,8 +202,10 @@ type TrafficKeys struct {
// NodeGet - struct for a single node get response
type NodeGet struct {
Node Node `json:"node" bson:"node" yaml:"node"`
Peers []wgtypes.PeerConfig `json:"peers" bson:"peers" yaml:"peers"`
Node Node `json:"node" bson:"node" yaml:"node"`
Host Host `json:"host" yaml:"host"`
// Peers are included in Node
//Peers []wgtypes.PeerConfig `json:"peers" bson:"peers" yaml:"peers"`
ServerConfig ServerConfig `json:"serverconfig" bson:"serverconfig" yaml:"serverconfig"`
PeerIDs PeerMap `json:"peerids,omitempty" bson:"peerids,omitempty" yaml:"peerids,omitempty"`
ProxyUpdate manager.ProxyManagerPayload `json:"proxy_update,omitempty" bson:"proxy_update,omitempty" yaml:"proxy_update,omitempty"`
@ -224,6 +225,7 @@ type ServerConfig struct {
Is_EE bool `yaml:"isee"`
StunPort int `yaml:"stun_port"`
StunHost string `yaml:"stun_host"`
TrafficKey []byte `yaml:"traffickey"`
}
// User.NameInCharset - returns if name is in charset below or not
@ -241,3 +243,10 @@ func (user *User) NameInCharSet() bool {
type ServerIDs struct {
ServerIDs []string `json:"server_ids"`
}
// JoinData - struct to hold data required for node to join a network on server
type JoinData struct {
Host Host `json:"host yaml:"host"`
Node Node `json:"node" yaml:"node"`
Key string `json:"key" yaml:"key"`
}

6
mq/handlers.go
View file

@ -85,7 +85,7 @@ func UpdateNode(client mqtt.Client, msg mqtt.Message) {
logger.Log(1, "failed to decrypt message for node ", id, decryptErr.Error())
return
}
var newNode models.Node
var newNode models.LegacyNode
if err := json.Unmarshal(decrypted, &newNode); err != nil {
logger.Log(1, "error unmarshaling payload ", err.Error())
return
@ -205,7 +205,7 @@ func ClientPeerUpdate(client mqtt.Client, msg mqtt.Message) {
}()
}
func updateNodePeers(currentNode *models.Node) {
func updateNodePeers(currentNode *models.LegacyNode) {
currentServerNode, err := logic.GetNetworkServerLocal(currentNode.Network)
if err != nil {
logger.Log(1, "failed to get server node failed update\n", err.Error())
@ -223,7 +223,7 @@ func updateNodePeers(currentNode *models.Node) {
}
}
func updateNodeMetrics(currentNode *models.Node, newMetrics *models.Metrics) bool {
func updateNodeMetrics(currentNode *models.LegacyNode, newMetrics *models.Metrics) bool {
if newMetrics.FailoverPeers == nil {
newMetrics.FailoverPeers = make(map[string]string)
}

12
mq/publishers.go
View file

@ -16,7 +16,7 @@ import (
)
// PublishPeerUpdate --- deterines and publishes a peer update to all the peers of a node
func PublishPeerUpdate(newNode *models.Node, publishToSelf bool) error {
func PublishPeerUpdate(newNode *models.LegacyNode, publishToSelf bool) error {
if !servercfg.IsMessageQueueBackend() {
return nil
}
@ -50,7 +50,7 @@ func PublishPeerUpdate(newNode *models.Node, publishToSelf bool) error {
return err
}
func PublishProxyPeerUpdate(node *models.Node) error {
func PublishProxyPeerUpdate(node *models.LegacyNode) error {
proxyUpdate, err := logic.GetPeersForProxy(node, false)
if err != nil {
return err
@ -65,7 +65,7 @@ func PublishProxyPeerUpdate(node *models.Node) error {
}
// PublishSinglePeerUpdate --- determines and publishes a peer update to one node
func PublishSinglePeerUpdate(node *models.Node) error {
func PublishSinglePeerUpdate(node *models.LegacyNode) error {
peerUpdate, err := logic.GetPeerUpdate(node)
if err != nil {
@ -89,7 +89,7 @@ func PublishSinglePeerUpdate(node *models.Node) error {
}
// PublishPeerUpdate --- publishes a peer update to all the peers of a node
func PublishExtPeerUpdate(node *models.Node) error {
func PublishExtPeerUpdate(node *models.LegacyNode) error {
var err error
if logic.IsLocalServer(node) {
if err = logic.ServerUpdate(node, false); err != nil {
@ -125,7 +125,7 @@ func PublishExtPeerUpdate(node *models.Node) error {
}
// NodeUpdate -- publishes a node update
func NodeUpdate(node *models.Node) error {
func NodeUpdate(node *models.LegacyNode) error {
var err error
if !servercfg.IsMessageQueueBackend() || node.IsServer == "yes" {
@ -157,7 +157,7 @@ func NodeUpdate(node *models.Node) error {
}
// ProxyUpdate -- publishes updates to peers related to proxy
func ProxyUpdate(proxyPayload *manager.ProxyManagerPayload, node *models.Node) error {
func ProxyUpdate(proxyPayload *manager.ProxyManagerPayload, node *models.LegacyNode) error {
if !servercfg.IsMessageQueueBackend() || !node.Proxy {
return nil
}

6
mq/util.go
View file

@ -11,7 +11,7 @@ import (
"github.com/gravitl/netmaker/netclient/ncutils"
)
func decryptMsg(node *models.Node, msg []byte) ([]byte, error) {
func decryptMsg(node *models.LegacyNode, msg []byte) ([]byte, error) {
if len(msg) <= 24 { // make sure message is of appropriate length
return nil, fmt.Errorf("recieved invalid message from broker %v", msg)
}
@ -36,7 +36,7 @@ func decryptMsg(node *models.Node, msg []byte) ([]byte, error) {
return ncutils.DeChunk(msg, nodePubTKey, serverPrivTKey)
}
func encryptMsg(node *models.Node, msg []byte) ([]byte, error) {
func encryptMsg(node *models.LegacyNode, msg []byte) ([]byte, error) {
// fetch server public key to be certain hasn't changed in transit
trafficKey, trafficErr := logic.RetrievePrivateTrafficKey()
if trafficErr != nil {
@ -60,7 +60,7 @@ func encryptMsg(node *models.Node, msg []byte) ([]byte, error) {
return ncutils.Chunk(msg, nodePubKey, serverPrivKey)
}
func publish(node *models.Node, dest string, msg []byte) error {
func publish(node *models.LegacyNode, dest string, msg []byte) error {
encrypted, encryptErr := encryptMsg(node, msg)
if encryptErr != nil {
return encryptErr

8
netclient/config/config.go
View file

@ -25,7 +25,7 @@ var (
// ClientConfig - struct for dealing with client configuration
type ClientConfig struct {
Server models.ServerConfig `yaml:"server"`
Node models.Node `yaml:"node"`
Node models.LegacyNode `yaml:"node"`
NetworkSettings models.Network `yaml:"networksettings"`
Network string `yaml:"network"`
Daemon string `yaml:"daemon"`
@ -138,7 +138,7 @@ func (config *ClientConfig) ReadConfig() {
}
// ModNodeConfig - overwrites the node inside client config on disk
func ModNodeConfig(node *models.Node) error {
func ModNodeConfig(node *models.LegacyNode) error {
network := node.Network
if network == "" {
return errors.New("no network provided")
@ -339,13 +339,13 @@ func FileExists(f string) bool {
}
// GetNode - parses a network specified client config for node data
func GetNode(network string) models.Node {
func GetNode(network string) models.LegacyNode {
modcfg, err := ReadConfig(network)
if err != nil {
log.Fatalf("Error: %v", err)
}
var node models.Node
var node models.LegacyNode
node.Fill(&modcfg.Node)
return node

4
netclient/functions/common.go
View file

@ -160,7 +160,7 @@ func getInterfaces() (*[]models.Iface, error) {
}
// GetNode - gets node locally
func GetNode(network string) models.Node {
func GetNode(network string) models.LegacyNode {
modcfg, err := config.ReadConfig(network)
if err != nil {
@ -422,7 +422,7 @@ func SetServerInfo(cfg *config.ClientConfig) error {
return nil
}
func informPortChange(node *models.Node) {
func informPortChange(node *models.LegacyNode) {
if node.ListenPort == 0 {
logger.Log(0, "network:", node.Network, "UDP hole punching enabled for node", node.Name)
} else {

2
netclient/functions/join.go
View file

@ -395,7 +395,7 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string) error {
}
// format name appropriately. Set to blank on failure
func formatName(node models.Node) string {
func formatName(node models.LegacyNode) string {
// Logic to properly format name
if !node.NameInNodeCharSet() {
node.Name = ncutils.DNSFormatString(node.Name)

2
netclient/functions/mqhandlers.go
View file

@ -52,7 +52,7 @@ func ProxyUpdate(client mqtt.Client, msg mqtt.Message) {
// NodeUpdate -- mqtt message handler for /update/<NodeID> topic
func NodeUpdate(client mqtt.Client, msg mqtt.Message) {
var newNode models.Node
var newNode models.LegacyNode
var nodeCfg config.ClientConfig
var network = parseNetworkFromTopic(msg.Topic())
nodeCfg.Network = network

2
netclient/functions/pull.go
View file

@ -20,7 +20,7 @@ import (
)
// Pull - pulls the latest config from the server, if manual it will overwrite
func Pull(network string, iface bool) (*models.Node, error) {
func Pull(network string, iface bool) (*models.LegacyNode, error) {
cfg, err := config.ReadConfig(network)
if err != nil {
return nil, err

2
netclient/ncutils/iface.go
View file

@ -7,7 +7,7 @@ import (
)
// IfaceDelta - checks if the new node causes an interface change
func IfaceDelta(currentNode *models.Node, newNode *models.Node) bool {
func IfaceDelta(currentNode *models.LegacyNode, newNode *models.LegacyNode) bool {
// single comparison statements
if newNode.Endpoint != currentNode.Endpoint ||
newNode.PublicKey != currentNode.PublicKey ||

2
netclient/ncutils/netclientutils.go
View file

@ -633,7 +633,7 @@ func GetIPNetFromString(ip string) (net.IPNet, error) {
}
// ModPort - Change Node Port if UDP Hole Punching or ListenPort is not free
func ModPort(node *models.Node) error {
func ModPort(node *models.LegacyNode) error {
var err error
if node.UDPHolePunch == "yes" {
node.ListenPort = 0

10
netclient/wireguard/common.go
View file

@ -24,7 +24,7 @@ const (
)
// SetPeers - sets peers on a given WireGuard interface
func SetPeers(iface string, node *models.Node, peers []wgtypes.PeerConfig) error {
func SetPeers(iface string, node *models.LegacyNode, peers []wgtypes.PeerConfig) error {
var devicePeers []wgtypes.Peer
var keepalive = node.PersistentKeepalive
var oldPeerAllowedIps = make(map[string]bool, len(peers))
@ -120,7 +120,7 @@ func SetPeers(iface string, node *models.Node, peers []wgtypes.PeerConfig) error
}
// Initializes a WireGuard interface
func InitWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig) error {
func InitWireguard(node *models.LegacyNode, privkey string, peers []wgtypes.PeerConfig) error {
key, err := wgtypes.ParseKey(privkey)
if err != nil {
@ -268,7 +268,7 @@ func RemoveConf(iface string, printlog bool) error {
}
// ApplyConf - applys a conf on disk to WireGuard interface
func ApplyConf(node *models.Node, ifacename string, confPath string) error {
func ApplyConf(node *models.LegacyNode, ifacename string, confPath string) error {
os := runtime.GOOS
if ncutils.IsLinux() && !ncutils.HasWgQuick() {
os = "nowgquick"
@ -305,7 +305,7 @@ func ApplyConf(node *models.Node, ifacename string, confPath string) error {
}
// WriteWgConfig - creates a wireguard config file
func WriteWgConfig(node *models.Node, privateKey string, peers []wgtypes.PeerConfig) error {
func WriteWgConfig(node *models.LegacyNode, privateKey string, peers []wgtypes.PeerConfig) error {
options := ini.LoadOptions{
AllowNonUniqueSections: true,
AllowShadows: true,
@ -434,7 +434,7 @@ func UpdateWgPeers(file string, peers []wgtypes.PeerConfig) (*net.UDPAddr, error
}
// UpdateWgInterface - updates the interface section of a wireguard config file
func UpdateWgInterface(file, privateKey, nameserver string, node models.Node) error {
func UpdateWgInterface(file, privateKey, nameserver string, node models.LegacyNode) error {
options := ini.LoadOptions{
AllowNonUniqueSections: true,
AllowShadows: true,

2
netclient/wireguard/noquick.go
View file

@ -19,7 +19,7 @@ import (
const disconnect_error = "node disconnected"
// ApplyWithoutWGQuick - Function for running the equivalent of "wg-quick up" for linux if wg-quick is missing
func ApplyWithoutWGQuick(node *models.Node, ifacename, confPath string, isConnected bool) error {
func ApplyWithoutWGQuick(node *models.LegacyNode, ifacename, confPath string, isConnected bool) error {
ipExec, err := exec.LookPath("ip")
if err != nil {

2
test/main.go
View file

@ -39,7 +39,7 @@ func main() {
pretty.Println(string(bytes))
}
defer response.Body.Close()
node := models.Node{}
node := models.LegacyNode{}
if err := json.NewDecoder(response.Body).Decode(&node); err != nil {
fmt.Println(err)
}