renamed files, fixed pointers

controllers/auth_grpc.go

@@ -17,6 +17,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
+// AuthServerUnaryInterceptor - auth unary interceptor logic
 func AuthServerUnaryInterceptor(ctx context.Context,
 	req interface{},
 	info *grpc.UnaryServerInfo,
@@ -38,6 +39,8 @@ func AuthServerUnaryInterceptor(ctx context.Context,
 
 	return h, err
 }
+
+// AuthServerStreamInterceptor - auth stream interceptor
 func AuthServerStreamInterceptor(
 	srv interface{},
 	stream grpc.ServerStream,

controllers/common.go

@@ -1,99 +0,0 @@
-package controller
-
-import (
-	"encoding/json"
-	"strings"
-
-	"github.com/gravitl/netmaker/database"
-	"github.com/gravitl/netmaker/logger"
-	"github.com/gravitl/netmaker/logic"
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/servercfg"
-)
-
-/**
- * If being deleted by server, create a record in the DELETED_NODES_TABLE for the client to find
- * If being deleted by the client, delete completely
- */
-// DeleteNode - deletes a node
-func DeleteNode(key string, exterminate bool) error {
-	var err error
-	if !exterminate {
-		args := strings.Split(key, "###")
-		node, err := GetNode(args[0], args[1])
-		if err != nil {
-			return err
-		}
-		node.Action = models.NODE_DELETE
-		nodedata, err := json.Marshal(&node)
-		if err != nil {
-			return err
-		}
-		err = database.Insert(key, string(nodedata), database.DELETED_NODES_TABLE_NAME)
-		if err != nil {
-			return err
-		}
-	} else {
-		if err := database.DeleteRecord(database.DELETED_NODES_TABLE_NAME, key); err != nil {
-			logger.Log(2, err.Error())
-		}
-	}
-	if err := database.DeleteRecord(database.NODES_TABLE_NAME, key); err != nil {
-		return err
-	}
-	if servercfg.IsDNSMode() {
-		err = logic.SetDNS()
-	}
-	return err
-}
-
-// DeleteIntClient - deletes an int client
-func DeleteIntClient(clientid string) (bool, error) {
-
-	err := database.DeleteRecord(database.INT_CLIENTS_TABLE_NAME, clientid)
-	if err != nil {
-		return false, err
-	}
-
-	return true, nil
-}
-
-// GetNode - gets a node
-func GetNode(macaddress string, network string) (models.Node, error) {
-
-	var node models.Node
-
-	key, err := logic.GetRecordKey(macaddress, network)
-	if err != nil {
-		return node, err
-	}
-	data, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
-	if err != nil {
-		if data == "" {
-			data, err = database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
-			err = json.Unmarshal([]byte(data), &node)
-		}
-		return node, err
-	}
-	if err = json.Unmarshal([]byte(data), &node); err != nil {
-		return node, err
-	}
-	logic.SetNodeDefaults(&node)
-
-	return node, err
-}
-
-// GetIntClient - gets int client
-func GetIntClient(clientid string) (models.IntClient, error) {
-
-	var client models.IntClient
-
-	value, err := database.FetchRecord(database.INT_CLIENTS_TABLE_NAME, clientid)
-	if err != nil {
-		return client, err
-	}
-	if err = json.Unmarshal([]byte(value), &client); err != nil {
-		return models.IntClient{}, err
-	}
-	return client, nil
-}

controllers/common_test.go

@@ -1,130 +0,0 @@
-package controller
-
-import (
-	"testing"
-
-	"github.com/gravitl/netmaker/database"
-	"github.com/gravitl/netmaker/logic"
-	"github.com/gravitl/netmaker/models"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGetPeerList(t *testing.T) {
-	database.InitializeDatabase()
-	deleteAllNetworks()
-	createNet()
-	t.Run("NoNodes", func(t *testing.T) {
-		peers, err := logic.GetPeersList("skynet", false, "")
-		assert.Nil(t, err)
-		assert.Nil(t, peers)
-	})
-	node := createTestNode()
-	t.Run("One Node", func(t *testing.T) {
-		peers, err := logic.GetPeersList("skynet", false, "")
-		assert.Nil(t, err)
-		assert.Equal(t, node.Address, peers[0].Address)
-	})
-	t.Run("Multiple Nodes", func(t *testing.T) {
-		createnode := &models.Node{PublicKey: "RM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.0.0.2", MacAddress: "02:02:03:04:05:06", Password: "password", Network: "skynet"}
-		logic.CreateNode(createnode, "skynet")
-		peers, err := logic.GetPeersList("skynet", false, "")
-		assert.Nil(t, err)
-		assert.Equal(t, len(peers), 2)
-		foundNodeEndpoint := false
-		for _, peer := range peers {
-			if foundNodeEndpoint = peer.Endpoint == createnode.Endpoint; foundNodeEndpoint {
-				break
-			}
-		}
-		assert.True(t, foundNodeEndpoint)
-	})
-}
-
-func TestDeleteNode(t *testing.T) {
-	database.InitializeDatabase()
-	deleteAllNetworks()
-	createNet()
-	node := createTestNode()
-	t.Run("NodeExists", func(t *testing.T) {
-		err := DeleteNode(node.MacAddress, true)
-		assert.Nil(t, err)
-	})
-	t.Run("NonExistantNode", func(t *testing.T) {
-		err := DeleteNode(node.MacAddress, true)
-		assert.Nil(t, err)
-	})
-}
-
-func TestGetNode(t *testing.T) {
-	database.InitializeDatabase()
-	deleteAllNetworks()
-	t.Run("NoNode", func(t *testing.T) {
-		response, err := GetNode("01:02:03:04:05:06", "skynet")
-		assert.Equal(t, models.Node{}, response)
-		assert.EqualError(t, err, "unexpected end of JSON input")
-	})
-	createNet()
-	node := createTestNode()
-
-	t.Run("NodeExists", func(t *testing.T) {
-		response, err := GetNode(node.MacAddress, node.Network)
-		assert.Nil(t, err)
-		assert.Equal(t, "10.0.0.1", response.Endpoint)
-		assert.Equal(t, "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", response.PublicKey)
-		assert.Equal(t, "01:02:03:04:05:06", response.MacAddress)
-		assert.Equal(t, int32(51821), response.ListenPort)
-		assert.NotNil(t, response.Name)
-		assert.Equal(t, "skynet", response.Network)
-		assert.Equal(t, "nm-skynet", response.Interface)
-	})
-	t.Run("BadMac", func(t *testing.T) {
-		response, err := GetNode("01:02:03:04:05:07", node.Network)
-		assert.Equal(t, models.Node{}, response)
-		assert.EqualError(t, err, "unexpected end of JSON input")
-	})
-	t.Run("BadNetwork", func(t *testing.T) {
-		response, err := GetNode(node.MacAddress, "badnet")
-		assert.Equal(t, models.Node{}, response)
-		assert.EqualError(t, err, "unexpected end of JSON input")
-	})
-
-}
-
-func TestCreateNode(t *testing.T) {
-	t.Skip()
-	database.InitializeDatabase()
-	deleteAllNetworks()
-	createNet()
-	createnode := &models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet"}
-	//err := ValidateNodeCreate("skynet", createnode)
-	//assert.Nil(t, err)
-	node, err := logic.CreateNode(createnode, "skynet")
-	assert.Nil(t, err)
-	assert.Equal(t, "10.0.0.1", node.Endpoint)
-	assert.Equal(t, "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", node.PublicKey)
-	assert.Equal(t, "01:02:03:04:05:06", node.MacAddress)
-	assert.Equal(t, int32(51821), node.ListenPort)
-	assert.NotNil(t, node.Name)
-	assert.Equal(t, "skynet", node.Network)
-	assert.Equal(t, "nm-skynet", node.Interface)
-}
-
-func TestSetNetworkNodesLastModified(t *testing.T) {
-	database.InitializeDatabase()
-	deleteAllNetworks()
-	createNet()
-	t.Run("InvalidNetwork", func(t *testing.T) {
-		err := logic.SetNetworkNodesLastModified("badnet")
-		assert.EqualError(t, err, "no result found")
-	})
-	t.Run("NetworkExists", func(t *testing.T) {
-		err := logic.SetNetworkNodesLastModified("skynet")
-		assert.Nil(t, err)
-	})
-}
-
-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"}
-	node, _ := logic.CreateNode(&createnode, "skynet")
-	return node
-}

controllers/node.go

@@ -328,7 +328,7 @@ func getNode(w http.ResponseWriter, r *http.Request) {
 
 	var params = mux.Vars(r)
 
-	node, err := GetNode(params["macaddress"], params["network"])
+	node, err := logic.GetNode(params["macaddress"], params["network"])
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
@@ -570,13 +570,17 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 
 	// get params
 	var params = mux.Vars(r)
-
+	var node, err = logic.GetNode(params["macaddress"], params["network"])
-	err := DeleteNode(params["macaddress"]+"###"+params["network"], false)
+	if err != nil {
-
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
+	err = logic.DeleteNode(&node, false)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
+
 	logger.Log(1, r.Header.Get("user"), "Deleted node", params["macaddress"], "from network", params["network"])
 	returnSuccessResponse(w, r, params["macaddress"]+" deleted.")
 }

controllers/node_grpc.go

@@ -25,7 +25,7 @@ func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.Object) (*
 	if len(macAndNetwork) != 2 {
 		return nil, errors.New("could not read node, invalid node id given")
 	}
-	node, err := GetNode(macAndNetwork[0], macAndNetwork[1])
+	node, err := logic.GetNode(macAndNetwork[0], macAndNetwork[1])
 	if err != nil {
 		return nil, err
 	}
@@ -135,8 +135,12 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
 // NodeServiceServer.DeleteNode - deletes a node and responds over gRPC
 func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
 	nodeID := req.GetData()
-
+	var nodeInfo = strings.Split(nodeID, "###")
-	err := DeleteNode(nodeID, true)
+	if len(nodeInfo) != 2 {
+		return nil, errors.New("node not found")
+	}
+	var node, err = logic.GetNode(nodeInfo[0], nodeInfo[1])
+	err = logic.DeleteNode(&node, true)
 	if err != nil {
 		return nil, err
 	}
@@ -152,7 +156,7 @@ func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*
 	macAndNetwork := strings.Split(req.Data, "###")
 	if len(macAndNetwork) == 2 {
 		// TODO: Make constant and new variable for isServer
-		node, err := GetNode(macAndNetwork[0], macAndNetwork[1])
+		node, err := logic.GetNode(macAndNetwork[0], macAndNetwork[1])
 		if err != nil {
 			return nil, err
 		}

controllers/node_test.go

@@ -144,13 +144,15 @@ func TestValidateEgressGateway(t *testing.T) {
 	})
 }
 
-//
-////func TestUpdateNode(t *testing.T) {
-////}
 func deleteAllNodes() {
 	nodes, _ := logic.GetAllNodes()
 	for _, node := range nodes {
-		key := node.MacAddress + "###" + node.Network
+		logic.DeleteNode(&node, true)
-		DeleteNode(key, true)
 	}
 }
+
+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"}
+	node, _ := logic.CreateNode(createnode, "skynet")
+	return node
+}