zishuo/netmaker
1
0
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-10-24 01:13:11 +08:00
Code Issues Packages Projects Releases Wiki Activity

renamed files, fixed pointers

Browse Source
This commit is contained in:
0xdcarns
2021-12-07 15:51:57 -05:00
parent 6215ea2db8
commit 09033e1e0b
6 changed files with 26 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
controllers/authGrpc.go → controllers/auth_grpc.go
View File

@@ -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,

99
controllers/common.go
View File

@@ -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
}

130
controllers/common_test.go
View File

@@ -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
}

12
controllers/node.go
View File

@@ -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)
err := DeleteNode(params["macaddress"]+"###"+params["network"], false)
var node, err = logic.GetNode(params["macaddress"], params["network"])
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.")
}

12
controllers/node_grpc.go
View File

@@ -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()
err := DeleteNode(nodeID, true)
var nodeInfo = strings.Split(nodeID, "###")
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
}

12
controllers/node_test.go
View File

@@ -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
DeleteNode(key, true)
logic.DeleteNode(&node, 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
}