mirror of
https://github.com/gravitl/netmaker.git
synced 2024-09-20 15:26:04 +08:00
rebase
Signed-off-by: Matthew R. Kasun <mkasun@nusak.ca>
This commit is contained in:
parent
a5e6aea563
commit
c086e9499d
|
@ -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")
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
@ -480,7 +480,7 @@ func getNode(w http.ResponseWriter, r *http.Request) {
|
|||
|
||||
response := models.NodeGet{
|
||||
Node: node,
|
||||
Peers: peerUpdate.Peers,
|
||||
//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))
|
||||
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
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
||||
|
|
|
@ -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))
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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), ¤tNode); err != nil {
|
||||
continue
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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
132
logic/nodes.go
|
@ -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 {
|
||||
|
|
|
@ -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 != "" {
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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{
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
182
models/node.go
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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"
|
||||
|
@ -177,7 +176,7 @@ type RelayRequest struct {
|
|||
// and if it should set peers
|
||||
type ServerUpdateData struct {
|
||||
UpdatePeers bool `json:"updatepeers" bson:"updatepeers"`
|
||||
Node Node `json:"servernode" bson:"servernode"`
|
||||
Node LegacyNode `json:"servernode" bson:"servernode"`
|
||||
}
|
||||
|
||||
// Telemetry - contains UUID of the server and timestamp of last send to posthog
|
||||
|
@ -204,7 +203,9 @@ 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"`
|
||||
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"`
|
||||
}
|
||||
|
|
|
@ -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)
|
||||
}
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 ||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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)
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue