re-enabled tests

controllers/dns.go

@@ -160,7 +160,7 @@ func createDNS(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	entry, err = CreateDNS(entry)
+	entry, err = logic.CreateDNS(entry)
 	if err != nil {
 		logger.Log(0, r.Header.Get("user"),
 			fmt.Sprintf("Failed to create DNS entry %+v: %v", entry, err))
@@ -223,22 +223,6 @@ func deleteDNS(w http.ResponseWriter, r *http.Request) {
 	json.NewEncoder(w).Encode(entrytext + " deleted.")
 }
 
-// CreateDNS - creates a DNS entry
-func CreateDNS(entry models.DNSEntry) (models.DNSEntry, error) {
-
-	data, err := json.Marshal(&entry)
-	if err != nil {
-		return models.DNSEntry{}, err
-	}
-	key, err := logic.GetRecordKey(entry.Name, entry.Network)
-	if err != nil {
-		return models.DNSEntry{}, err
-	}
-	err = database.Insert(key, string(data), database.DNS_TABLE_NAME)
-
-	return entry, err
-}
-
 // GetDNSEntry - gets a DNS entry
 func GetDNSEntry(domain string, network string) (models.DNSEntry, error) {
 	var entry models.DNSEntry

controllers/dns_test.go

@@ -1,35 +1,45 @@
 package controller
 
 import (
+	"net"
 	"os"
 	"testing"
 
+	"github.com/google/uuid"
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
 	"github.com/stretchr/testify/assert"
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
+var dnsHost models.Host
+
 func TestGetAllDNS(t *testing.T) {
 	database.InitializeDatabase()
 	deleteAllDNS(t)
 	deleteAllNetworks()
 	createNet()
+	createHost()
 	t.Run("NoEntries", func(t *testing.T) {
 		entries, err := logic.GetAllDNS()
 		assert.Nil(t, err)
 		assert.Equal(t, []models.DNSEntry(nil), entries)
 	})
 	t.Run("OneEntry", func(t *testing.T) {
-		entry := models.DNSEntry{"10.0.0.3", "", "newhost", "skynet"}
+		entry := models.DNSEntry{
-		CreateDNS(entry)
+			"10.0.0.3", "", "newhost", "skynet",
+		}
+		_, err := logic.CreateDNS(entry)
+		assert.Nil(t, err)
 		entries, err := logic.GetAllDNS()
 		assert.Nil(t, err)
 		assert.Equal(t, 1, len(entries))
 	})
 	t.Run("MultipleEntry", func(t *testing.T) {
 		entry := models.DNSEntry{"10.0.0.7", "", "anotherhost", "skynet"}
-		CreateDNS(entry)
+		_, err := logic.CreateDNS(entry)
+		assert.Nil(t, err)
 		entries, err := logic.GetAllDNS()
 		assert.Nil(t, err)
 		assert.Equal(t, 2, len(entries))
@@ -41,22 +51,42 @@ func TestGetNodeDNS(t *testing.T) {
 	deleteAllDNS(t)
 	deleteAllNetworks()
 	createNet()
+	createHost()
 	t.Run("NoNodes", func(t *testing.T) {
 		dns, err := logic.GetNodeDNS("skynet")
 		assert.EqualError(t, err, "could not find any records")
 		assert.Equal(t, []models.DNSEntry(nil), dns)
 	})
 	t.Run("NodeExists", 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: "linux", DNSOn: "yes"}
+		createHost()
-		err := logic.CreateNode(&createnode)
+		_, ipnet, _ := net.ParseCIDR("10.0.0.1/32")
+		tmpCNode := models.CommonNode{
+			ID:      uuid.New(),
+			Network: "skynet",
+			Address: *ipnet,
+			DNSOn:   true,
+		}
+		createnode := models.Node{
+			CommonNode: tmpCNode,
+		}
+		err := logic.AssociateNodeToHost(&createnode, &dnsHost)
 		assert.Nil(t, err)
 		dns, err := logic.GetNodeDNS("skynet")
 		assert.Nil(t, err)
 		assert.Equal(t, "10.0.0.1", dns[0].Address)
 	})
 	t.Run("MultipleNodes", func(t *testing.T) {
-		createnode := &models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.100.100.3", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet"}
+		_, ipnet, _ := net.ParseCIDR("10.100.100.3/32")
-		err := logic.CreateNode(createnode)
+		tmpCNode := models.CommonNode{
+			ID:      uuid.New(),
+			Network: "skynet",
+			Address: *ipnet,
+			DNSOn:   true,
+		}
+		createnode := models.Node{
+			CommonNode: tmpCNode,
+		}
+		err := logic.AssociateNodeToHost(&createnode, &dnsHost)
 		assert.Nil(t, err)
 		dns, err := logic.GetNodeDNS("skynet")
 		assert.Nil(t, err)
@@ -85,15 +115,16 @@ func TestGetCustomDNS(t *testing.T) {
 		assert.Equal(t, 0, len(dns))
 	})
 	t.Run("EntryExist", func(t *testing.T) {
-		entry := models.DNSEntry{"10.0.0.3", "", "newhost", "skynet"}
+		entry := models.DNSEntry{"10.0.0.3", "", "custom1", "skynet"}
-		CreateDNS(entry)
+		_, err := logic.CreateDNS(entry)
 		dns, err := logic.GetCustomDNS("skynet")
 		assert.Nil(t, err)
 		assert.Equal(t, 1, len(dns))
 	})
 	t.Run("MultipleEntries", func(t *testing.T) {
 		entry := models.DNSEntry{"10.0.0.4", "", "host4", "skynet"}
-		CreateDNS(entry)
+		_, err := logic.CreateDNS(entry)
+		assert.Nil(t, err)
 		dns, err := logic.GetCustomDNS("skynet")
 		assert.Nil(t, err)
 		assert.Equal(t, 2, len(dns))
@@ -112,7 +143,7 @@ func TestGetDNSEntryNum(t *testing.T) {
 	})
 	t.Run("NodeExists", func(t *testing.T) {
 		entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
-		_, err := CreateDNS(entry)
+		_, err := logic.CreateDNS(entry)
 		assert.Nil(t, err)
 		num, err := logic.GetDNSEntryNum("newhost", "skynet")
 		assert.Nil(t, err)
@@ -131,7 +162,7 @@ func TestGetDNS(t *testing.T) {
 	})
 	t.Run("CustomDNSExists", func(t *testing.T) {
 		entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
-		_, err := CreateDNS(entry)
+		_, err := logic.CreateDNS(entry)
 		assert.Nil(t, err)
 		dns, err := logic.GetDNS("skynet")
 		t.Log(dns)
@@ -151,7 +182,7 @@ func TestGetDNS(t *testing.T) {
 	})
 	t.Run("NodeAndCustomDNS", func(t *testing.T) {
 		entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
-		_, err := CreateDNS(entry)
+		_, err := logic.CreateDNS(entry)
 		assert.Nil(t, err)
 		dns, err := logic.GetDNS("skynet")
 		t.Log(dns)
@@ -169,7 +200,7 @@ func TestCreateDNS(t *testing.T) {
 	deleteAllNetworks()
 	createNet()
 	entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
-	dns, err := CreateDNS(entry)
+	dns, err := logic.CreateDNS(entry)
 	assert.Nil(t, err)
 	assert.Equal(t, "newhost", dns.Name)
 }
@@ -204,12 +235,13 @@ func TestSetDNS(t *testing.T) {
 		assert.False(t, info.IsDir())
 		content, err := os.ReadFile("./config/dnsconfig/netmaker.hosts")
 		assert.Nil(t, err)
-		assert.Contains(t, string(content), "testnode.skynet")
+		assert.Contains(t, string(content), "linuxhost.skynet")
 	})
 	t.Run("EntryExists", func(t *testing.T) {
 		entry := models.DNSEntry{"10.0.0.3", "", "newhost", "skynet"}
-		CreateDNS(entry)
+		_, err := logic.CreateDNS(entry)
-		err := logic.SetDNS()
+		assert.Nil(t, err)
+		err = logic.SetDNS()
 		assert.Nil(t, err)
 		info, err := os.Stat("./config/dnsconfig/netmaker.hosts")
 		assert.Nil(t, err)
@@ -228,7 +260,7 @@ func TestGetDNSEntry(t *testing.T) {
 	createNet()
 	createTestNode()
 	entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
-	CreateDNS(entry)
+	_, _ = logic.CreateDNS(entry)
 	t.Run("wrong net", func(t *testing.T) {
 		entry, err := GetDNSEntry("newhost", "w286 Toronto Street South, Uxbridge, ONirecat")
 		assert.EqualError(t, err, "no result found")
@@ -251,40 +283,13 @@ func TestGetDNSEntry(t *testing.T) {
 	})
 }
 
-//	func TestUpdateDNS(t *testing.T) {
-//		var newentry models.DNSEntry
-//		database.InitializeDatabase()
-//		deleteAllDNS(t)
-//		deleteAllNetworks()
-//		createNet()
-//		entry := models.DNSEntry{"10.0.0.2", "newhost", "skynet"}
-//		CreateDNS(entry)
-//		t.Run("change address", func(t *testing.T) {
-//			newentry.Address = "10.0.0.75"
-//			updated, err := UpdateDNS(newentry, entry)
-//			assert.Nil(t, err)
-//			assert.Equal(t, newentry.Address, updated.Address)
-//		})
-//		t.Run("change name", func(t *testing.T) {
-//			newentry.Name = "newname"
-//			updated, err := UpdateDNS(newentry, entry)
-//			assert.Nil(t, err)
-//			assert.Equal(t, newentry.Name, updated.Name)
-//		})
-//		t.Run("change network", func(t *testing.T) {
-//			newentry.Network = "wirecat"
-//			updated, err := UpdateDNS(newentry, entry)
-//			assert.Nil(t, err)
-//			assert.NotEqual(t, newentry.Network, updated.Network)
-//		})
-//	}
 func TestDeleteDNS(t *testing.T) {
 	database.InitializeDatabase()
 	deleteAllDNS(t)
 	deleteAllNetworks()
 	createNet()
 	entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
-	CreateDNS(entry)
+	_, _ = logic.CreateDNS(entry)
 	t.Run("EntryExists", func(t *testing.T) {
 		err := logic.DeleteDNS("newhost", "skynet")
 		assert.Nil(t, err)
@@ -351,8 +356,8 @@ func TestValidateDNSUpdate(t *testing.T) {
 	})
 	t.Run("NameUnique", func(t *testing.T) {
 		change := models.DNSEntry{"10.0.0.2", "", "myhost", "wirecat"}
-		CreateDNS(entry)
+		_, _ = logic.CreateDNS(entry)
-		CreateDNS(change)
+		_, _ = logic.CreateDNS(change)
 		err := logic.ValidateDNSUpdate(change, entry)
 		assert.NotNil(t, err)
 		assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'name_unique' tag")
@@ -401,13 +406,25 @@ func TestValidateDNSCreate(t *testing.T) {
 	})
 	t.Run("NameUnique", func(t *testing.T) {
 		entry := models.DNSEntry{"10.0.0.2", "", "myhost", "skynet"}
-		_, _ = CreateDNS(entry)
+		_, _ = logic.CreateDNS(entry)
 		err := logic.ValidateDNSCreate(entry)
 		assert.NotNil(t, err)
 		assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'name_unique' tag")
 	})
 }
 
+func createHost() {
+	k, _ := wgtypes.ParseKey("DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=")
+	dnsHost = models.Host{
+		ID:        uuid.New(),
+		PublicKey: k.PublicKey(),
+		HostPass:  "password",
+		OS:        "linux",
+		Name:      "dnshost",
+	}
+	_ = logic.CreateHost(&dnsHost)
+}
+
 func deleteAllDNS(t *testing.T) {
 	dns, err := logic.GetAllDNS()
 	assert.Nil(t, err)

controllers/network_test.go

@@ -4,10 +4,12 @@ import (
 	"os"
 	"testing"
 
+	"github.com/google/uuid"
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
 	"github.com/stretchr/testify/assert"
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
 type NetworkValidationTestCase struct {
@@ -16,6 +18,8 @@ type NetworkValidationTestCase struct {
 	errMessage string
 }
 
+var netHost models.Host
+
 func TestCreateNetwork(t *testing.T) {
 	initialize()
 	deleteAllNetworks()
@@ -305,11 +309,12 @@ func TestIpv6Network(t *testing.T) {
 		assert.Nil(t, err)
 		assert.Equal(t, network.AddressRange6, "fde6:be04:fa5e:d076::/64")
 	})
-	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"}
+	node1 := createNodeWithParams("skynet6", "")
-	nodeErr := logic.CreateNode(&node1)
+	createNetHost()
+	nodeErr := logic.AssociateNodeToHost(node1, &netHost)
 	t.Run("Test node on network IPv6", func(t *testing.T) {
 		assert.Nil(t, nodeErr)
-		assert.Equal(t, "fde6:be04:fa5e:d076::1", node1.Address6)
+		assert.Equal(t, "fde6:be04:fa5e:d076::1", node1.Address6.IP.String())
 	})
 }
 
@@ -358,3 +363,15 @@ func createNetDualStack() {
 		logic.CreateNetwork(network)
 	}
 }
+
+func createNetHost() {
+	k, _ := wgtypes.ParseKey("DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=")
+	netHost = models.Host{
+		ID:        uuid.New(),
+		PublicKey: k.PublicKey(),
+		HostPass:  "password",
+		OS:        "linux",
+		Name:      "nethost",
+	}
+	_ = logic.CreateHost(&netHost)
+}

controllers/node_test.go

@@ -1,16 +1,22 @@
 package controller
 
 import (
+	"net"
 	"testing"
 
+	"github.com/google/uuid"
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/logic/acls"
 	"github.com/gravitl/netmaker/logic/acls/nodeacls"
 	"github.com/gravitl/netmaker/models"
 	"github.com/stretchr/testify/assert"
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
+var nonLinuxHost models.Host
+var linuxHost models.Host
+
 func TestCreateEgressGateway(t *testing.T) {
 	var gateway models.EgressGatewayRequest
 	gateway.Interface = "eth0"
@@ -21,22 +27,24 @@ func TestCreateEgressGateway(t *testing.T) {
 	createNet()
 	t.Run("NoNodes", func(t *testing.T) {
 		node, err := logic.CreateEgressGateway(gateway)
-		assert.Equal(t, models.LegacyNode{}, node)
+		assert.Equal(t, models.Node{}, node)
 		assert.EqualError(t, err, "could not find any records")
 	})
 	t.Run("Non-linux node", func(t *testing.T) {
-		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"}
+		createnode := createNodeWithParams("", "")
-		err := logic.CreateNode(&createnode)
+		createNodeHosts()
+		createnode.HostID = nonLinuxHost.ID
+		err := logic.AssociateNodeToHost(createnode, &nonLinuxHost)
 		assert.Nil(t, err)
-		gateway.NodeID = createnode.ID
+		gateway.NodeID = createnode.ID.String()
 		node, err := logic.CreateEgressGateway(gateway)
-		assert.Equal(t, models.LegacyNode{}, node)
+		assert.Equal(t, models.Node{}, node)
 		assert.EqualError(t, err, "windows is unsupported for egress gateways")
 	})
 	t.Run("Success-Nat-Enabled", func(t *testing.T) {
 		deleteAllNodes()
 		testnode := createTestNode()
-		gateway.NodeID = testnode.ID
+		gateway.NodeID = testnode.ID.String()
 		gateway.NatEnabled = "yes"
 
 		node, err := logic.CreateEgressGateway(gateway)
@@ -50,7 +58,7 @@ func TestCreateEgressGateway(t *testing.T) {
 	t.Run("Success-Nat-Disabled", func(t *testing.T) {
 		deleteAllNodes()
 		testnode := createTestNode()
-		gateway.NodeID = testnode.ID
+		gateway.NodeID = testnode.ID.String()
 		gateway.NatEnabled = "no"
 
 		node, err := logic.CreateEgressGateway(gateway)
@@ -68,14 +76,14 @@ func TestCreateEgressGateway(t *testing.T) {
 		gateway.NetID = "skynet"
 		deleteAllNodes()
 		testnode := createTestNode()
-		gateway.NodeID = testnode.ID
+		gateway.NodeID = testnode.ID.String()
 
 		node, err := logic.CreateEgressGateway(gateway)
 		t.Log(node)
 		assert.Nil(t, err)
 		assert.Contains(t, node.PostUp, "-j MASQUERADE")
 		assert.Contains(t, node.PostDown, "-j MASQUERADE")
-		assert.Equal(t, "yes", node.IsEgressGateway)
+		assert.Equal(t, true, node.IsEgressGateway)
 		assert.Equal(t, gateway.Ranges, node.EgressGatewayRanges)
 	})
 
@@ -89,15 +97,15 @@ func TestDeleteEgressGateway(t *testing.T) {
 	gateway.Interface = "eth0"
 	gateway.Ranges = []string{"10.100.100.0/24"}
 	gateway.NetID = "skynet"
-	gateway.NodeID = testnode.ID
+	gateway.NodeID = testnode.ID.String()
 	t.Run("Success", func(t *testing.T) {
 		node, err := logic.CreateEgressGateway(gateway)
 		assert.Nil(t, err)
-		assert.Equal(t, "yes", node.IsEgressGateway)
+		assert.Equal(t, true, node.IsEgressGateway)
 		assert.Equal(t, []string{"10.100.100.0/24"}, node.EgressGatewayRanges)
 		node, err = logic.DeleteEgressGateway(gateway.NetID, gateway.NodeID)
 		assert.Nil(t, err)
-		assert.Equal(t, "no", node.IsEgressGateway)
+		assert.Equal(t, false, node.IsEgressGateway)
 		assert.Equal(t, []string([]string{}), node.EgressGatewayRanges)
 		assert.Equal(t, "", node.PostUp)
 		assert.Equal(t, "", node.PostDown)
@@ -105,7 +113,7 @@ func TestDeleteEgressGateway(t *testing.T) {
 	t.Run("NotGateway", func(t *testing.T) {
 		node, err := logic.DeleteEgressGateway(gateway.NetID, gateway.NodeID)
 		assert.Nil(t, err)
-		assert.Equal(t, "no", node.IsEgressGateway)
+		assert.Equal(t, false, node.IsEgressGateway)
 		assert.Equal(t, []string([]string{}), node.EgressGatewayRanges)
 		assert.Equal(t, "", node.PostUp)
 		assert.Equal(t, "", node.PostDown)
@@ -113,7 +121,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.LegacyNode{}, node)
+		assert.Equal(t, models.Node{}, node)
 		deleteAllNodes()
 	})
 }
@@ -140,23 +148,7 @@ func TestGetNetworkNodes(t *testing.T) {
 	})
 
 }
-func TestUncordonNode(t *testing.T) {
-	database.InitializeDatabase()
-	deleteAllNetworks()
-	createNet()
-	node := createTestNode()
-	t.Run("BadID", func(t *testing.T) {
-		resp, err := logic.UncordonNode("blahblah")
-		assert.Equal(t, models.LegacyNode{}, resp)
-		assert.EqualError(t, err, "no result found")
-	})
-	t.Run("Success", func(t *testing.T) {
-		resp, err := logic.UncordonNode(node.ID)
-		assert.Nil(t, err)
-		assert.Equal(t, "no", resp.IsPending)
-	})
 
-}
 func TestValidateEgressGateway(t *testing.T) {
 	var gateway models.EgressGatewayRequest
 	t.Run("EmptyRange", func(t *testing.T) {
@@ -181,66 +173,73 @@ func TestValidateEgressGateway(t *testing.T) {
 
 func TestNodeACLs(t *testing.T) {
 	deleteAllNodes()
-	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"}
+	node1 := createNodeWithParams("", "10.0.0.50/32")
-	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"}
+	node2 := createNodeWithParams("", "10.0.0.100/32")
-	logic.CreateNode(&node1)
+	logic.AssociateNodeToHost(node1, &linuxHost)
-	logic.CreateNode(&node2)
+	logic.AssociateNodeToHost(node2, &linuxHost)
 	t.Run("acls not present", func(t *testing.T) {
 		currentACL, err := nodeacls.FetchAllACLs(nodeacls.NetworkID(node1.Network))
 		assert.Nil(t, err)
 		assert.NotNil(t, currentACL)
-		node1ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID))
+		node1ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID.String()))
 		assert.Nil(t, err)
 		assert.NotNil(t, node1ACL)
-		assert.Equal(t, acls.Allowed, node1ACL[acls.AclID(node2.ID)])
+		assert.Equal(t, acls.Allowed, node1ACL[acls.AclID(node2.ID.String())])
 	})
 	t.Run("node acls exists after creates", func(t *testing.T) {
-		node1ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID))
+		node1ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID.String()))
 		assert.Nil(t, err)
 		assert.NotNil(t, node1ACL)
-		node2ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node2.Network), nodeacls.NodeID(node2.ID))
+		node2ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node2.Network), nodeacls.NodeID(node2.ID.String()))
 		assert.Nil(t, err)
 		assert.NotNil(t, node2ACL)
-		assert.Equal(t, acls.Allowed, node2ACL[acls.AclID(node1.ID)])
+		assert.Equal(t, acls.Allowed, node2ACL[acls.AclID(node1.ID.String())])
 	})
 	t.Run("node acls correct after fetch", func(t *testing.T) {
-		node1ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID))
+		node1ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID.String()))
 		assert.Nil(t, err)
-		assert.Equal(t, acls.Allowed, node1ACL[acls.AclID(node2.ID)])
+		assert.Equal(t, acls.Allowed, node1ACL[acls.AclID(node2.ID.String())])
 	})
 	t.Run("node acls correct after modify", func(t *testing.T) {
-		node1ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID))
+		node1ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID.String()))
 		assert.Nil(t, err)
 		assert.NotNil(t, node1ACL)
-		node2ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node2.Network), nodeacls.NodeID(node2.ID))
+		node2ACL, err := nodeacls.FetchNodeACL(nodeacls.NetworkID(node2.Network), nodeacls.NodeID(node2.ID.String()))
 		assert.Nil(t, err)
 		assert.NotNil(t, node2ACL)
-		currentACL, err := nodeacls.DisallowNodes(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID), nodeacls.NodeID(node2.ID))
+		currentACL, err := nodeacls.DisallowNodes(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID.String()), nodeacls.NodeID(node2.ID.String()))
 		assert.Nil(t, err)
-		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node1.ID)][acls.AclID(node2.ID)])
+		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node1.ID.String())][acls.AclID(node2.ID.String())])
-		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node2.ID)][acls.AclID(node1.ID)])
+		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node2.ID.String())][acls.AclID(node1.ID.String())])
 		currentACL.Save(acls.ContainerID(node1.Network))
 	})
 	t.Run("node acls correct after add new node not allowed", func(t *testing.T) {
-		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"}
+		node3 := createNodeWithParams("", "10.0.0.100/32")
-		logic.CreateNode(&node3)
+		createNodeHosts()
-		var currentACL, err = nodeacls.FetchAllACLs(nodeacls.NetworkID(node3.Network))
+		n, e := logic.GetNetwork(node3.Network)
+		assert.Nil(t, e)
+		n.DefaultACL = "no"
+		e = logic.SaveNetwork(&n)
+		assert.Nil(t, e)
+		err := logic.AssociateNodeToHost(node3, &linuxHost)
+		assert.Nil(t, err)
+		currentACL, err := nodeacls.FetchAllACLs(nodeacls.NetworkID(node3.Network))
 		assert.Nil(t, err)
 		assert.NotNil(t, currentACL)
-		assert.Equal(t, acls.NotPresent, currentACL[acls.AclID(node1.ID)][acls.AclID(node3.ID)])
+		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node1.ID.String())][acls.AclID(node3.ID.String())])
-		nodeACL, err := nodeacls.CreateNodeACL(nodeacls.NetworkID(node3.Network), nodeacls.NodeID(node3.ID), acls.NotAllowed)
+		nodeACL, err := nodeacls.CreateNodeACL(nodeacls.NetworkID(node3.Network), nodeacls.NodeID(node3.ID.String()), acls.NotAllowed)
 		assert.Nil(t, err)
-		nodeACL.Save(acls.ContainerID(node3.Network), acls.AclID(node3.ID))
+		nodeACL.Save(acls.ContainerID(node3.Network), acls.AclID(node3.ID.String()))
 		currentACL, err = nodeacls.FetchAllACLs(nodeacls.NetworkID(node3.Network))
 		assert.Nil(t, err)
-		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node1.ID)][acls.AclID(node3.ID)])
+		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node1.ID.String())][acls.AclID(node3.ID.String())])
-		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node2.ID)][acls.AclID(node3.ID)])
+		assert.Equal(t, acls.NotAllowed, currentACL[acls.AclID(node2.ID.String())][acls.AclID(node3.ID.String())])
 	})
 	t.Run("node acls removed", func(t *testing.T) {
-		retNetworkACL, err := nodeacls.RemoveNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID))
+		retNetworkACL, err := nodeacls.RemoveNodeACL(nodeacls.NetworkID(node1.Network), nodeacls.NodeID(node1.ID.String()))
 		assert.Nil(t, err)
 		assert.NotNil(t, retNetworkACL)
-		assert.Equal(t, acls.NotPresent, retNetworkACL[acls.AclID(node2.ID)][acls.AclID(node1.ID)])
+		assert.Equal(t, acls.NotPresent, retNetworkACL[acls.AclID(node2.ID.String())][acls.AclID(node1.ID.String())])
 	})
 	deleteAllNodes()
 }
@@ -249,8 +248,51 @@ func deleteAllNodes() {
 	database.DeleteAllRecords(database.NODES_TABLE_NAME)
 }
 
-func createTestNode() *models.LegacyNode {
+func createTestNode() *models.Node {
-	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"}
+	createNodeHosts()
-	logic.CreateNode(&createnode)
+	n := createNodeWithParams("skynet", "")
+	_ = logic.AssociateNodeToHost(n, &linuxHost)
+	return n
+}
+
+func createNodeWithParams(network, address string) *models.Node {
+	_, ipnet, _ := net.ParseCIDR("10.0.0.1/32")
+	tmpCNode := models.CommonNode{
+		ID:      uuid.New(),
+		Network: "skynet",
+		Address: *ipnet,
+		DNSOn:   true,
+	}
+	if len(network) > 0 {
+		tmpCNode.Network = network
+	}
+	if len(address) > 0 {
+		_, ipnet2, _ := net.ParseCIDR(address)
+		tmpCNode.Address = *ipnet2
+	}
+	createnode := models.Node{
+		CommonNode: tmpCNode,
+	}
 	return &createnode
 }
+
+func createNodeHosts() {
+	k, _ := wgtypes.ParseKey("DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=")
+	linuxHost = models.Host{
+		ID:        uuid.New(),
+		PublicKey: k.PublicKey(),
+		HostPass:  "password",
+		OS:        "linux",
+		Name:      "linuxhost",
+	}
+	_ = logic.CreateHost(&linuxHost)
+	nonLinuxHost = models.Host{
+		ID:        uuid.New(),
+		OS:        "windows",
+		PublicKey: k.PublicKey(),
+		Name:      "windowshost",
+		HostPass:  "password",
+	}
+
+	_ = logic.CreateHost(&nonLinuxHost)
+}

logic/dns.go

@@ -74,14 +74,27 @@ func GetNodeDNS(network string) ([]models.DNSEntry, error) {
 	}
 
 	for _, value := range collection {
-		var entry models.DNSEntry
 		var node models.Node
 		if err = json.Unmarshal([]byte(value), &node); err != nil {
 			continue
 		}
-		if err = json.Unmarshal([]byte(value), &entry); node.Network == network && err == nil {
+		if node.Network != network {
-			dns = append(dns, entry)
+			continue
 		}
+		host, err := GetHost(node.HostID.String())
+		if err != nil {
+			continue
+		}
+		var entry = models.DNSEntry{}
+		entry.Name = host.Name
+		entry.Network = network
+		if node.Address.IP != nil {
+			entry.Address = node.Address.IP.String()
+		}
+		if node.Address6.IP != nil {
+			entry.Address6 = node.Address6.IP.String()
+		}
+		dns = append(dns, entry)
 	}
 
 	return dns, nil
@@ -220,9 +233,6 @@ func ValidateDNSUpdate(change models.DNSEntry, entry models.DNSEntry) error {
 	})
 	_ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
 		_, err := GetParentNetwork(change.Network)
-		if err != nil {
-			logger.Log(0, err.Error())
-		}
 		return err == nil
 	})
 
@@ -245,3 +255,20 @@ func DeleteDNS(domain string, network string) error {
 	err = database.DeleteRecord(database.DNS_TABLE_NAME, key)
 	return err
 }
+
+// CreateDNS - creates a DNS entry
+func CreateDNS(entry models.DNSEntry) (models.DNSEntry, error) {
+
+	k, err := GetRecordKey(entry.Name, entry.Network)
+	if err != nil {
+		return models.DNSEntry{}, err
+	}
+
+	data, err := json.Marshal(&entry)
+	if err != nil {
+		return models.DNSEntry{}, err
+	}
+
+	err = database.Insert(k, string(data), database.DNS_TABLE_NAME)
+	return entry, err
+}

logic/pro/networkuser_test.go

@@ -3,6 +3,7 @@ package pro
 import (
 	"testing"
 
+	"github.com/google/uuid"
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/models/promodels"
@@ -18,8 +19,13 @@ func TestNetworkUserLogic(t *testing.T) {
 		NetID:        "skynet",
 		AddressRange: "192.168.0.0/24",
 	}
-	nodes := []models.LegacyNode{
+	tmpCNode := models.CommonNode{
-		models.LegacyNode{ID: "coolnode"},
+		ID: uuid.New(),
+	}
+	tempNode := models.Node{}
+	tempNode.CommonNode = tmpCNode
+	nodes := []models.Node{
+		tempNode,
 	}
 
 	clients := []models.ExtClient{
@@ -63,10 +69,10 @@ func TestNetworkUserLogic(t *testing.T) {
 	})
 
 	t.Run("Successful net user node isallowed", func(t *testing.T) {
-		networkUser.Nodes = append(networkUser.Nodes, "coolnode")
+		networkUser.Nodes = append(networkUser.Nodes, nodes[0].ID.String())
 		err := UpdateNetworkUser(network.NetID, &networkUser)
 		assert.Nil(t, err)
-		isUserNodeAllowed := IsUserNodeAllowed(nodes[:], network.NetID, string(networkUser.ID), "coolnode")
+		isUserNodeAllowed := IsUserNodeAllowed(nodes[:], network.NetID, string(networkUser.ID), nodes[0].ID.String())
 		assert.True(t, isUserNodeAllowed)
 	})
 

models/dnsEntry.go

@@ -1,4 +1,4 @@
-//TODO:  Either add a returnNetwork and returnKey, or delete this
+// TODO:  Either add a returnNetwork and returnKey, or delete this
 package models
 
 // DNSEntry - a DNS entry represented as struct