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

refactored logic

Browse Source
This commit is contained in:
0xdcarns
2021-10-26 12:27:29 -04:00
parent d25cc93598
commit 8f72ecbaa0
33 changed files with 985 additions and 1092 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
controllers/authGrpc.go
View File

@@ -8,6 +8,7 @@ import (
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/functions"
nodepb "github.com/gravitl/netmaker/grpc"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"golang.org/x/crypto/bcrypt"
"google.golang.org/grpc"
@@ -68,7 +69,7 @@ func grpcAuthorize(ctx context.Context) error {
authToken := authHeader[0]
mac, network, err := functions.VerifyToken(authToken)
mac, network, err := logic.VerifyToken(authToken)
if err != nil {
return err
}
@@ -79,9 +80,9 @@ func grpcAuthorize(ctx context.Context) error {
return status.Errorf(codes.Unauthenticated, "Unauthorized. Network does not exist: "+network)
}
emptynode := models.Node{}
node, err := functions.GetNodeByMacAddress(network, mac)
node, err := logic.GetNodeByMacAddress(network, mac)
if database.IsEmptyRecord(err) {
if node, err = functions.GetDeletedNodeByMacAddress(network, mac); err == nil {
if node, err = logic.GetDeletedNodeByMacAddress(network, mac); err == nil {
if functions.RemoveDeletedNode(node.ID) {
return status.Errorf(codes.Unauthenticated, models.NODE_DELETE)
}
@@ -146,7 +147,7 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nod
return nil, err
} else {
//Create a new JWT for the node
tokenString, err := functions.CreateJWT(macaddress, result.Network)
tokenString, err := logic.CreateJWT(macaddress, result.Network)
if err != nil {
return nil, err

8
controllers/common.go
View File

@@ -5,8 +5,8 @@ import (
"strings"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/dnslogic"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/servercfg"
)
@@ -41,7 +41,7 @@ func DeleteNode(key string, exterminate bool) error {
return err
}
if servercfg.IsDNSMode() {
err = dnslogic.SetDNS()
err = logic.SetDNS()
}
return err
}
@@ -60,7 +60,7 @@ func GetNode(macaddress string, network string) (models.Node, error) {
var node models.Node
key, err := functions.GetRecordKey(macaddress, network)
key, err := logic.GetRecordKey(macaddress, network)
if err != nil {
return node, err
}
@@ -75,7 +75,7 @@ func GetNode(macaddress string, network string) (models.Node, error) {
if err = json.Unmarshal([]byte(data), &node); err != nil {
return node, err
}
node.SetDefaults()
logic.SetNodeDefaults(&node)
return node, err
}

34
controllers/dnsHttpController.go
View File

@@ -7,8 +7,8 @@ import (
"github.com/go-playground/validator/v10"
"github.com/gorilla/mux"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/dnslogic"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
)
@@ -59,12 +59,12 @@ func getAllDNS(w http.ResponseWriter, r *http.Request) {
// GetAllDNS - gets all dns entries
func GetAllDNS() ([]models.DNSEntry, error) {
var dns []models.DNSEntry
networks, err := models.GetNetworks()
networks, err := logic.GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
return []models.DNSEntry{}, err
}
for _, net := range networks {
netdns, err := dnslogic.GetDNS(net.NetID)
netdns, err := logic.GetDNS(net.NetID)
if err != nil {
return []models.DNSEntry{}, nil
}
@@ -105,7 +105,7 @@ func getCustomDNS(w http.ResponseWriter, r *http.Request) {
var dns []models.DNSEntry
var params = mux.Vars(r)
dns, err := dnslogic.GetCustomDNS(params["network"])
dns, err := logic.GetCustomDNS(params["network"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -121,7 +121,7 @@ func GetDNSEntryNum(domain string, network string) (int, error) {
num := 0
entries, err := dnslogic.GetDNS(network)
entries, err := logic.GetDNS(network)
if err != nil {
return 0, err
}
@@ -144,7 +144,7 @@ func getDNS(w http.ResponseWriter, r *http.Request) {
var dns []models.DNSEntry
var params = mux.Vars(r)
dns, err := dnslogic.GetDNS(params["network"])
dns, err := logic.GetDNS(params["network"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -174,7 +174,7 @@ func createDNS(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
err = dnslogic.SetDNS()
err = logic.SetDNS()
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -229,7 +229,7 @@ func updateDNS(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "badrequest"))
return
}
err = dnslogic.SetDNS()
err = logic.SetDNS()
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -252,7 +252,7 @@ func deleteDNS(w http.ResponseWriter, r *http.Request) {
}
entrytext := params["domain"] + "." + params["network"]
functions.PrintUserLog(models.NODE_SERVER_NAME, "deleted dns entry: "+entrytext, 1)
err = dnslogic.SetDNS()
err = logic.SetDNS()
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -267,7 +267,7 @@ func CreateDNS(entry models.DNSEntry) (models.DNSEntry, error) {
if err != nil {
return models.DNSEntry{}, err
}
key, err := functions.GetRecordKey(entry.Name, entry.Network)
key, err := logic.GetRecordKey(entry.Name, entry.Network)
if err != nil {
return models.DNSEntry{}, err
}
@@ -279,7 +279,7 @@ func CreateDNS(entry models.DNSEntry) (models.DNSEntry, error) {
// GetDNSEntry - gets a DNS entry
func GetDNSEntry(domain string, network string) (models.DNSEntry, error) {
var entry models.DNSEntry
key, err := functions.GetRecordKey(domain, network)
key, err := logic.GetRecordKey(domain, network)
if err != nil {
return entry, err
}
@@ -294,7 +294,7 @@ func GetDNSEntry(domain string, network string) (models.DNSEntry, error) {
// UpdateDNS - updates DNS entry
func UpdateDNS(dnschange models.DNSEntry, entry models.DNSEntry) (models.DNSEntry, error) {
key, err := functions.GetRecordKey(entry.Name, entry.Network)
key, err := logic.GetRecordKey(entry.Name, entry.Network)
if err != nil {
return entry, err
}
@@ -304,7 +304,7 @@ func UpdateDNS(dnschange models.DNSEntry, entry models.DNSEntry) (models.DNSEntr
if dnschange.Address != "" {
entry.Address = dnschange.Address
}
newkey, err := functions.GetRecordKey(entry.Name, entry.Network)
newkey, err := logic.GetRecordKey(entry.Name, entry.Network)
err = database.DeleteRecord(database.DNS_TABLE_NAME, key)
if err != nil {
@@ -318,7 +318,7 @@ func UpdateDNS(dnschange models.DNSEntry, entry models.DNSEntry) (models.DNSEntr
// DeleteDNS - deletes a DNS entry
func DeleteDNS(domain string, network string) error {
key, err := functions.GetRecordKey(domain, network)
key, err := logic.GetRecordKey(domain, network)
if err != nil {
return err
}
@@ -330,7 +330,7 @@ func pushDNS(w http.ResponseWriter, r *http.Request) {
// Set header
w.Header().Set("Content-Type", "application/json")
err := dnslogic.SetDNS()
err := logic.SetDNS()
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
@@ -351,7 +351,7 @@ func ValidateDNSCreate(entry models.DNSEntry) error {
})
_ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
_, err := functions.GetParentNetwork(entry.Network)
_, err := logic.GetParentNetwork(entry.Network)
return err == nil
})
@@ -378,7 +378,7 @@ func ValidateDNSUpdate(change models.DNSEntry, entry models.DNSEntry) error {
return err == nil && num == 0
})
_ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
_, err := functions.GetParentNetwork(change.Network)
_, err := logic.GetParentNetwork(change.Network)
if err != nil {
functions.PrintUserLog("", err.Error(), 0)
}

27
controllers/dnsHttpController_test.go
View File

@@ -6,7 +6,6 @@ import (
"testing"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/dnslogic"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/stretchr/testify/assert"
@@ -68,33 +67,33 @@ func TestGetCustomDNS(t *testing.T) {
deleteAllDNS(t)
deleteAllNetworks()
t.Run("NoNetworks", func(t *testing.T) {
dns, err := dnslogic.GetCustomDNS("skynet")
dns, err := logic.GetCustomDNS("skynet")
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, []models.DNSEntry(nil), dns)
})
t.Run("NoNodes", func(t *testing.T) {
createNet()
dns, err := dnslogic.GetCustomDNS("skynet")
dns, err := logic.GetCustomDNS("skynet")
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, []models.DNSEntry(nil), dns)
})
t.Run("NodeExists", func(t *testing.T) {
createTestNode()
dns, err := dnslogic.GetCustomDNS("skynet")
dns, err := logic.GetCustomDNS("skynet")
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, 0, len(dns))
})
t.Run("EntryExist", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.3", "newhost", "skynet"}
CreateDNS(entry)
dns, err := dnslogic.GetCustomDNS("skynet")
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)
dns, err := dnslogic.GetCustomDNS("skynet")
dns, err := logic.GetCustomDNS("skynet")
assert.Nil(t, err)
assert.Equal(t, 2, len(dns))
})
@@ -125,7 +124,7 @@ func TestGetDNS(t *testing.T) {
deleteAllNetworks()
createNet()
t.Run("NoEntries", func(t *testing.T) {
dns, err := dnslogic.GetDNS("skynet")
dns, err := logic.GetDNS("skynet")
assert.Nil(t, err)
assert.Nil(t, dns)
})
@@ -133,7 +132,7 @@ func TestGetDNS(t *testing.T) {
entry := models.DNSEntry{"10.0.0.2", "newhost", "skynet"}
_, err := CreateDNS(entry)
assert.Nil(t, err)
dns, err := dnslogic.GetDNS("skynet")
dns, err := logic.GetDNS("skynet")
t.Log(dns)
assert.Nil(t, err)
assert.NotNil(t, dns)
@@ -143,7 +142,7 @@ func TestGetDNS(t *testing.T) {
t.Run("NodeExists", func(t *testing.T) {
deleteAllDNS(t)
createTestNode()
dns, err := dnslogic.GetDNS("skynet")
dns, err := logic.GetDNS("skynet")
assert.Nil(t, err)
assert.NotNil(t, dns)
assert.Equal(t, "skynet", dns[0].Network)
@@ -152,7 +151,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)
dns, err := dnslogic.GetDNS("skynet")
dns, err := logic.GetDNS("skynet")
t.Log(dns)
assert.Nil(t, err)
assert.NotNil(t, dns)
@@ -178,7 +177,7 @@ func TestSetDNS(t *testing.T) {
deleteAllDNS(t)
deleteAllNetworks()
t.Run("NoNetworks", func(t *testing.T) {
err := dnslogic.SetDNS()
err := logic.SetDNS()
assert.Nil(t, err)
info, err := os.Stat("./config/dnsconfig/netmaker.hosts")
assert.Nil(t, err)
@@ -187,7 +186,7 @@ func TestSetDNS(t *testing.T) {
})
t.Run("NoEntries", func(t *testing.T) {
createNet()
err := dnslogic.SetDNS()
err := logic.SetDNS()
assert.Nil(t, err)
info, err := os.Stat("./config/dnsconfig/netmaker.hosts")
assert.Nil(t, err)
@@ -196,7 +195,7 @@ func TestSetDNS(t *testing.T) {
})
t.Run("NodeExists", func(t *testing.T) {
createTestNode()
err := dnslogic.SetDNS()
err := logic.SetDNS()
assert.Nil(t, err)
info, err := os.Stat("./config/dnsconfig/netmaker.hosts")
assert.Nil(t, err)
@@ -208,7 +207,7 @@ func TestSetDNS(t *testing.T) {
t.Run("EntryExists", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.3", "newhost", "skynet"}
CreateDNS(entry)
err := dnslogic.SetDNS()
err := logic.SetDNS()
assert.Nil(t, err)
info, err := os.Stat("./config/dnsconfig/netmaker.hosts")
assert.Nil(t, err)

20
controllers/extClientHttpController.go
View File

@@ -30,7 +30,7 @@ func extClientHandlers(r *mux.Router) {
}
func checkIngressExists(network string, macaddress string) bool {
node, err := functions.GetNodeByMacAddress(network, macaddress)
node, err := logic.GetNodeByMacAddress(network, macaddress)
if err != nil {
return false
}
@@ -133,7 +133,7 @@ func getExtClient(w http.ResponseWriter, r *http.Request) {
// GetExtClient - gets a single ext client on a network
func GetExtClient(clientid string, network string) (models.ExtClient, error) {
var extclient models.ExtClient
key, err := functions.GetRecordKey(clientid, network)
key, err := logic.GetRecordKey(clientid, network)
if err != nil {
return extclient, err
}
@@ -160,14 +160,14 @@ func getExtClientConf(w http.ResponseWriter, r *http.Request) {
return
}
gwnode, err := functions.GetNodeByMacAddress(client.Network, client.IngressGatewayID)
gwnode, err := logic.GetNodeByMacAddress(client.Network, client.IngressGatewayID)
if err != nil {
functions.PrintUserLog(r.Header.Get("user"), "Could not retrieve Ingress Gateway Node "+client.IngressGatewayID, 1)
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
network, err := functions.GetParentNetwork(client.Network)
network, err := logic.GetParentNetwork(client.Network)
if err != nil {
functions.PrintUserLog(r.Header.Get("user"), "Could not retrieve Ingress Gateway Network "+client.Network, 1)
returnErrorResponse(w, r, formatError(err, "internal"))
@@ -179,7 +179,7 @@ func getExtClientConf(w http.ResponseWriter, r *http.Request) {
}
gwendpoint := gwnode.Endpoint + ":" + strconv.Itoa(int(gwnode.ListenPort))
newAllowedIPs := network.AddressRange
if egressGatewayRanges, err := client.GetEgressRangesOnNetwork(); err == nil {
if egressGatewayRanges, err := logic.GetEgressRangesOnNetwork(&client); err == nil {
for _, egressGatewayRange := range egressGatewayRanges {
newAllowedIPs += "," + egressGatewayRange
}
@@ -252,7 +252,7 @@ func CreateExtClient(extclient models.ExtClient) error {
}
if extclient.Address == "" {
newAddress, err := functions.UniqueAddress(extclient.Network)
newAddress, err := logic.UniqueAddress(extclient.Network)
if err != nil {
return err
}
@@ -265,7 +265,7 @@ func CreateExtClient(extclient models.ExtClient) error {
extclient.LastModified = time.Now().Unix()
key, err := functions.GetRecordKey(extclient.ClientID, extclient.Network)
key, err := logic.GetRecordKey(extclient.ClientID, extclient.Network)
if err != nil {
return err
}
@@ -300,7 +300,7 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
var extclient models.ExtClient
extclient.Network = networkName
extclient.IngressGatewayID = macaddress
node, err := functions.GetNodeByMacAddress(networkName, macaddress)
node, err := logic.GetNodeByMacAddress(networkName, macaddress)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -329,7 +329,7 @@ func updateExtClient(w http.ResponseWriter, r *http.Request) {
var oldExtClient models.ExtClient
_ = json.NewDecoder(r.Body).Decode(&newExtClient)
key, err := functions.GetRecordKey(params["clientid"], params["network"])
key, err := logic.GetRecordKey(params["clientid"], params["network"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -367,7 +367,7 @@ func UpdateExtClient(newclientid string, network string, client models.ExtClient
// DeleteExtClient - deletes an existing ext client
func DeleteExtClient(network string, clientid string) error {
key, err := functions.GetRecordKey(clientid, network)
key, err := logic.GetRecordKey(clientid, network)
if err != nil {
return err
}

24
controllers/networkHttpController.go
View File

@@ -83,7 +83,7 @@ func SecurityCheck(reqAdmin bool, netname string, token string) (error, []string
isMasterAuthenticated := authenticateMaster(authToken)
username := ""
if !hasBearer || !isMasterAuthenticated {
userName, networks, isadmin, err := functions.VerifyUserToken(authToken)
userName, networks, isadmin, err := logic.VerifyUserToken(authToken)
username = userName
if err != nil {
return errors.New("error verifying user token"), nil, username
@@ -133,14 +133,14 @@ func getNetworks(w http.ResponseWriter, r *http.Request) {
allnetworks := []models.Network{}
err := errors.New("Networks Error")
if networksSlice[0] == ALL_NETWORK_ACCESS {
allnetworks, err = models.GetNetworks()
allnetworks, err = logic.GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
} else {
for _, network := range networksSlice {
netObject, parentErr := functions.GetParentNetwork(network)
netObject, parentErr := logic.GetParentNetwork(network)
if parentErr == nil {
allnetworks = append(allnetworks, netObject)
}
@@ -228,7 +228,7 @@ func KeyUpdate(netname string) (models.Network, error) {
func AlertNetwork(netid string) error {
var network models.Network
network, err := functions.GetParentNetwork(netid)
network, err := logic.GetParentNetwork(netid)
if err != nil {
return err
}
@@ -249,7 +249,7 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
var params = mux.Vars(r)
var network models.Network
netname := params["networkname"]
network, err := functions.GetParentNetwork(netname)
network, err := logic.GetParentNetwork(netname)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -260,21 +260,21 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "badrequest"))
return
}
rangeupdate, localrangeupdate, err := network.Update(&newNetwork)
rangeupdate, localrangeupdate, err := logic.UpdateNetwork(&network, &newNetwork)
if err != nil {
returnErrorResponse(w, r, formatError(err, "badrequest"))
return
}
if rangeupdate {
err = functions.UpdateNetworkNodeAddresses(network.NetID)
err = logic.UpdateNetworkNodeAddresses(network.NetID)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
}
if localrangeupdate {
err = functions.UpdateNetworkLocalAddresses(network.NetID)
err = logic.UpdateNetworkLocalAddresses(network.NetID)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -290,7 +290,7 @@ func updateNetworkNodeLimit(w http.ResponseWriter, r *http.Request) {
var params = mux.Vars(r)
var network models.Network
netname := params["networkname"]
network, err := functions.GetParentNetwork(netname)
network, err := logic.GetParentNetwork(netname)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -390,7 +390,7 @@ func CreateNetwork(network models.Network) error {
network.SetNetworkLastModified()
network.KeyUpdateTimeStamp = time.Now().Unix()
err := network.Validate(false)
err := logic.ValidateNetwork(&network, false)
if err != nil {
//returnErrorResponse(w, r, formatError(err, "badrequest"))
return err
@@ -425,7 +425,7 @@ func createAccessKey(w http.ResponseWriter, r *http.Request) {
var accesskey models.AccessKey
//start here
netname := params["networkname"]
network, err := functions.GetParentNetwork(netname)
network, err := logic.GetParentNetwork(netname)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -604,7 +604,7 @@ func deleteAccessKey(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}
func DeleteKey(keyname, netname string) error {
network, err := functions.GetParentNetwork(netname)
network, err := logic.GetParentNetwork(netname)
if err != nil {
return err
}

3
controllers/networkHttpController_test.go
View File

@@ -5,6 +5,7 @@ import (
"time"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/stretchr/testify/assert"
)
@@ -333,7 +334,7 @@ func TestValidateNetworkUpdate(t *testing.T) {
func deleteAllNetworks() {
deleteAllNodes()
nets, _ := models.GetNetworks()
nets, _ := logic.GetNetworks()
for _, net := range nets {
DeleteNetwork(net.NetID)
}

10
controllers/nodeGrpcController.go
View File

@@ -35,7 +35,7 @@ func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.Object) (*
if err != nil {
return nil, err
}
node.Update(&node)
logic.UpdateNode(&node, &node)
response := &nodepb.Object{
Data: string(nodeData),
Type: nodepb.NODE_TYPE,
@@ -55,8 +55,8 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.Object)
//Check to see if key is valid
//TODO: Triple inefficient!!! This is the third call to the DB we make for networks
validKey := functions.IsKeyValid(node.Network, node.AccessKey)
network, err := functions.GetParentNetwork(node.Network)
validKey := logic.IsKeyValid(node.Network, node.AccessKey)
network, err := logic.GetParentNetwork(node.Network)
if err != nil {
return nil, err
}
@@ -99,11 +99,11 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
macaddress := newnode.MacAddress
networkName := newnode.Network
node, err := functions.GetNodeByMacAddress(networkName, macaddress)
node, err := logic.GetNodeByMacAddress(networkName, macaddress)
if err != nil {
return nil, err
}
err = node.Update(&newnode)
err = logic.UpdateNode(&node, &newnode)
if err != nil {
return nil, err
}

50
controllers/nodeHttpController.go
View File

@@ -9,7 +9,6 @@ import (
"github.com/gorilla/mux"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/dnslogic"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
@@ -107,7 +106,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
return
} else {
//Create a new JWT for the node
tokenString, _ := functions.CreateJWT(authRequest.MacAddress, result.Network)
tokenString, _ := logic.CreateJWT(authRequest.MacAddress, result.Network)
if tokenString == "" {
errorResponse.Code = http.StatusBadRequest
@@ -193,7 +192,7 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
//TODO: There's probably a better way of dealing with the "master token"/master password. Plz Help.
var isAuthorized = false
var macaddress = ""
username, networks, isadmin, errN := functions.VerifyUserToken(authToken)
username, networks, isadmin, errN := logic.VerifyUserToken(authToken)
isnetadmin := isadmin
if errN == nil && isadmin {
macaddress = "mastermac"
@@ -221,7 +220,7 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
if isnetadmin {
isAuthorized = true
} else {
node, err := functions.GetNodeByMacAddress(params["network"], macaddress)
node, err := logic.GetNodeByMacAddress(params["network"], macaddress)
if err != nil {
errorResponse = models.ErrorResponse{
Code: http.StatusUnauthorized, Message: "W1R3: Missing Auth Token.",
@@ -285,14 +284,14 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
//Not quite sure if this is necessary. Probably necessary based on front end but may want to review after iteration 1 if it's being used or not
func getAllNodes(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
user, err := functions.GetUser(r.Header.Get("user"))
user, err := logic.GetUser(r.Header.Get("user"))
if err != nil && r.Header.Get("ismasterkey") != "yes" {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
var nodes []models.Node
if user.IsAdmin || r.Header.Get("ismasterkey") == "yes" {
nodes, err = models.GetAllNodes()
nodes, err = logic.GetAllNodes()
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -392,7 +391,7 @@ func createNode(w http.ResponseWriter, r *http.Request) {
node.Network = networkName
network, err := node.GetNetwork()
network, err := logic.GetNetworkByNode(&node)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -400,7 +399,7 @@ func createNode(w http.ResponseWriter, r *http.Request) {
//Check to see if key is valid
//TODO: Triple inefficient!!! This is the third call to the DB we make for networks
validKey := functions.IsKeyValid(networkName, node.AccessKey)
validKey := logic.IsKeyValid(networkName, node.AccessKey)
if !validKey {
//Check to see if network will allow manual sign up
@@ -441,8 +440,9 @@ func uncordonNode(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode("SUCCESS")
}
// UncordonNode - approves a node to join a network
func UncordonNode(network, macaddress string) (models.Node, error) {
node, err := functions.GetNodeByMacAddress(network, macaddress)
node, err := logic.GetNodeByMacAddress(network, macaddress)
if err != nil {
return models.Node{}, err
}
@@ -453,7 +453,7 @@ func UncordonNode(network, macaddress string) (models.Node, error) {
if err != nil {
return node, err
}
key, err := functions.GetRecordKey(node.MacAddress, node.Network)
key, err := logic.GetRecordKey(node.MacAddress, node.Network)
if err != nil {
return node, err
}
@@ -483,8 +483,9 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(node)
}
// CreateEgressGateway - creates an egress gateway
func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, error) {
node, err := functions.GetNodeByMacAddress(gateway.NetID, gateway.NodeID)
node, err := logic.GetNodeByMacAddress(gateway.NetID, gateway.NodeID)
if node.OS == "windows" || node.OS == "macos" { // add in darwin later
return models.Node{}, errors.New(node.OS + " is unsupported for egress gateways")
}
@@ -515,7 +516,7 @@ func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, erro
postDownCmd = node.PostDown + "; " + postDownCmd
}
}
key, err := functions.GetRecordKey(gateway.NodeID, gateway.NetID)
key, err := logic.GetRecordKey(gateway.NodeID, gateway.NetID)
if err != nil {
return node, err
}
@@ -565,9 +566,10 @@ func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(node)
}
// DeleteEgressGateway - deletes egress from node
func DeleteEgressGateway(network, macaddress string) (models.Node, error) {
node, err := functions.GetNodeByMacAddress(network, macaddress)
node, err := logic.GetNodeByMacAddress(network, macaddress)
if err != nil {
return models.Node{}, err
}
@@ -582,7 +584,7 @@ func DeleteEgressGateway(network, macaddress string) (models.Node, error) {
}
node.SetLastModified()
node.PullChanges = "yes"
key, err := functions.GetRecordKey(node.MacAddress, node.Network)
key, err := logic.GetRecordKey(node.MacAddress, node.Network)
if err != nil {
return models.Node{}, err
}
@@ -615,9 +617,10 @@ func createIngressGateway(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(node)
}
// CreateIngressGateway - creates an ingress gateway
func CreateIngressGateway(netid string, macaddress string) (models.Node, error) {
node, err := functions.GetNodeByMacAddress(netid, macaddress)
node, err := logic.GetNodeByMacAddress(netid, macaddress)
if node.OS == "windows" || node.OS == "macos" { // add in darwin later
return models.Node{}, errors.New(node.OS + " is unsupported for ingress gateways")
}
@@ -626,7 +629,7 @@ func CreateIngressGateway(netid string, macaddress string) (models.Node, error)
return models.Node{}, err
}
network, err := functions.GetParentNetwork(netid)
network, err := logic.GetParentNetwork(netid)
if err != nil {
return models.Node{}, err
}
@@ -649,7 +652,7 @@ func CreateIngressGateway(netid string, macaddress string) (models.Node, error)
node.PostDown = postDownCmd
node.PullChanges = "yes"
node.UDPHolePunch = "no"
key, err := functions.GetRecordKey(node.MacAddress, node.Network)
key, err := logic.GetRecordKey(node.MacAddress, node.Network)
if err != nil {
return models.Node{}, err
}
@@ -679,13 +682,14 @@ func deleteIngressGateway(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(node)
}
// DeleteIngressGateway - deletes an ingress gateway
func DeleteIngressGateway(networkName string, macaddress string) (models.Node, error) {
node, err := functions.GetNodeByMacAddress(networkName, macaddress)
node, err := logic.GetNodeByMacAddress(networkName, macaddress)
if err != nil {
return models.Node{}, err
}
network, err := functions.GetParentNetwork(networkName)
network, err := logic.GetParentNetwork(networkName)
if err != nil {
return models.Node{}, err
}
@@ -700,7 +704,7 @@ func DeleteIngressGateway(networkName string, macaddress string) (models.Node, e
node.IngressGatewayRange = ""
node.PullChanges = "yes"
key, err := functions.GetRecordKey(node.MacAddress, node.Network)
key, err := logic.GetRecordKey(node.MacAddress, node.Network)
if err != nil {
return models.Node{}, err
}
@@ -723,7 +727,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
var node models.Node
//start here
node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
node, err := logic.GetNodeByMacAddress(params["network"], params["macaddress"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -749,7 +753,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
}
}
}
err = node.Update(&newNode)
err = logic.UpdateNode(&node, &newNode)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -762,7 +766,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
}
if servercfg.IsDNSMode() {
err = dnslogic.SetDNS()
err = logic.SetDNS()
}
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))

2
controllers/nodeHttpController_test.go
View File

@@ -148,7 +148,7 @@ func TestValidateEgressGateway(t *testing.T) {
////func TestUpdateNode(t *testing.T) {
////}
func deleteAllNodes() {
nodes, _ := models.GetAllNodes()
nodes, _ := logic.GetAllNodes()
for _, node := range nodes {
key := node.MacAddress + "###" + node.Network
DeleteNode(key, true)

9
controllers/relay.go
View File

@@ -9,6 +9,7 @@ import (
"github.com/gorilla/mux"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
)
@@ -35,7 +36,7 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
// CreateRelay - creates a relay
func CreateRelay(relay models.RelayRequest) (models.Node, error) {
node, err := functions.GetNodeByMacAddress(relay.NetID, relay.NodeID)
node, err := logic.GetNodeByMacAddress(relay.NetID, relay.NodeID)
if node.OS == "windows" || node.OS == "macos" { // add in darwin later
return models.Node{}, errors.New(node.OS + " is unsupported for relay")
}
@@ -49,7 +50,7 @@ func CreateRelay(relay models.RelayRequest) (models.Node, error) {
node.IsRelay = "yes"
node.RelayAddrs = relay.RelayAddrs
key, err := functions.GetRecordKey(relay.NodeID, relay.NetID)
key, err := logic.GetRecordKey(relay.NodeID, relay.NetID)
if err != nil {
return node, err
}
@@ -147,7 +148,7 @@ func UpdateRelay(network string, oldAddrs []string, newAddrs []string) {
// DeleteRelay - deletes a relay
func DeleteRelay(network, macaddress string) (models.Node, error) {
node, err := functions.GetNodeByMacAddress(network, macaddress)
node, err := logic.GetNodeByMacAddress(network, macaddress)
if err != nil {
return models.Node{}, err
}
@@ -160,7 +161,7 @@ func DeleteRelay(network, macaddress string) (models.Node, error) {
node.RelayAddrs = []string{}
node.SetLastModified()
node.PullChanges = "yes"
key, err := functions.GetRecordKey(node.MacAddress, node.Network)
key, err := logic.GetRecordKey(node.MacAddress, node.Network)
if err != nil {
return models.Node{}, err
}

4
controllers/serverHttpController.go
View File

@@ -6,7 +6,7 @@ import (
"strings"
"github.com/gorilla/mux"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/servercfg"
"github.com/gravitl/netmaker/serverctl"
@@ -42,7 +42,7 @@ func securityCheckServer(adminonly bool, next http.Handler) http.HandlerFunc {
}
//all endpoints here require master so not as complicated
//still might not be a good way of doing this
user, _, isadmin, err := functions.VerifyUserToken(authToken)
user, _, isadmin, err := logic.VerifyUserToken(authToken)
errorResponse = models.ErrorResponse{
Code: http.StatusUnauthorized, Message: "W1R3: You are unauthorized to access this endpoint.",
}

2
controllers/userHttpController.go
View File

@@ -143,7 +143,7 @@ func ValidateUserToken(token string, user string, adminonly bool) error {
return errors.New("Missing Auth Token.")
}
username, _, isadmin, err := functions.VerifyUserToken(authToken)
username, _, isadmin, err := logic.VerifyUserToken(authToken)
if err != nil {
return errors.New("Error Verifying Auth Token")
}

397
functions/helpers.go
View File

@@ -1,21 +1,15 @@
//TODO: Consider restructuring this file/folder "github.com/gorilla/handlers"
//It may make more sense to split into different files and not call it "helpers"
package functions
import (
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"log"
"math/rand"
"net"
"strings"
"time"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/servercfg"
)
@@ -59,20 +53,6 @@ func ParseIntClient(value string) (models.IntClient, error) {
//Takes in an arbitrary field and value for field and checks to see if any other
//node has that value for the same field within the network
// GetUser - gets a user
func GetUser(username string) (models.User, error) {
var user models.User
record, err := database.FetchRecord(database.USERS_TABLE_NAME, username)
if err != nil {
return user, err
}
if err = json.Unmarshal([]byte(record), &user); err != nil {
return models.User{}, err
}
return user, err
}
// SliceContains - sees if a slice contains something
func SliceContains(slice []string, item string) bool {
set := make(map[string]struct{}, len(slice))
@@ -84,60 +64,6 @@ func SliceContains(slice []string, item string) bool {
return ok
}
// CreateServerToken - creates a server token
func CreateServerToken(netID string) (string, error) {
var network models.Network
var accesskey models.AccessKey
network, err := GetParentNetwork(netID)
if err != nil {
return "", err
}
var accessToken models.AccessToken
servervals := models.ServerConfig{}
if servercfg.GetPlatform() == "Kubernetes" {
log.Println("server on kubernetes")
servervals = models.ServerConfig{
APIConnString: servercfg.GetPodIP() + ":" + servercfg.GetAPIPort(),
GRPCConnString: servercfg.GetPodIP() + ":" + servercfg.GetGRPCPort(),
GRPCSSL: "off",
}
} else {
log.Println("server on linux")
servervals = models.ServerConfig{
APIConnString: "127.0.0.1:" + servercfg.GetAPIPort(),
GRPCConnString: "127.0.0.1:" + servercfg.GetGRPCPort(),
GRPCSSL: "off",
CheckinInterval: servercfg.GetCheckinInterval(),
}
}
log.Println("APIConnString:", servervals.APIConnString)
log.Println("GRPCConnString:", servervals.GRPCConnString)
log.Println("GRPCSSL:", servervals.GRPCSSL)
accessToken.ServerConfig = servervals
accessToken.ClientConfig.Network = netID
accessToken.ClientConfig.Key = GenKey()
accesskey.Name = GenKeyName()
accesskey.Value = accessToken.ClientConfig.Key
accesskey.Uses = 1
tokenjson, err := json.Marshal(accessToken)
if err != nil {
return accesskey.AccessString, err
}
accesskey.AccessString = base64.StdEncoding.EncodeToString([]byte(tokenjson))
log.Println("accessstring:", accesskey.AccessString)
network.AccessKeys = append(network.AccessKeys, accesskey)
if data, err := json.Marshal(network); err != nil {
return "", err
} else {
database.Insert(netID, string(data), database.NETWORKS_TABLE_NAME)
}
return accesskey.AccessString, nil
}
// GetPeersList - gets peers for given network
func GetPeersList(networkName string) ([]models.PeersResponse, error) {
@@ -214,51 +140,6 @@ func NetworkExists(name string) (bool, error) {
return len(network) > 0, nil
}
// GetRecordKey - get record key
func GetRecordKey(id string, network string) (string, error) {
if id == "" || network == "" {
return "", errors.New("unable to get record key")
}
return id + "###" + network, nil
}
// UpdateNetworkNodeAddresses - updates network node addresses
func UpdateNetworkNodeAddresses(networkName string) error {
collections, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
return err
}
for _, value := range collections {
var node models.Node
err := json.Unmarshal([]byte(value), &node)
if err != nil {
fmt.Println("error in node address assignment!")
return err
}
if node.Network == networkName {
ipaddr, iperr := UniqueAddress(networkName)
if iperr != nil {
fmt.Println("error in node address assignment!")
return iperr
}
node.Address = ipaddr
node.PullChanges = "yes"
data, err := json.Marshal(&node)
if err != nil {
return err
}
node.SetID()
database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
}
}
return nil
}
// NetworkNodesUpdateAction - updates action of network nodes
func NetworkNodesUpdateAction(networkName string, action string) error {
@@ -325,51 +206,12 @@ func NetworkNodesUpdatePullChanges(networkName string) error {
return nil
}
// UpdateNetworkLocalAddresses - updates network localaddresses
func UpdateNetworkLocalAddresses(networkName string) error {
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
return err
}
for _, value := range collection {
var node models.Node
err := json.Unmarshal([]byte(value), &node)
if err != nil {
fmt.Println("error in node address assignment!")
return err
}
if node.Network == networkName {
ipaddr, iperr := UniqueAddress(networkName)
if iperr != nil {
fmt.Println("error in node address assignment!")
return iperr
}
node.Address = ipaddr
newNodeData, err := json.Marshal(&node)
if err != nil {
fmt.Println("error in node address assignment!")
return err
}
node.SetID()
database.Insert(node.ID, string(newNodeData), database.NODES_TABLE_NAME)
}
}
return nil
}
// IsNetworkDisplayNameUnique - checks if network display name unique
func IsNetworkDisplayNameUnique(name string) (bool, error) {
isunique := true
dbs, err := models.GetNetworks()
dbs, err := logic.GetNetworks()
if err != nil {
return database.IsEmptyRecord(err), err
}
@@ -417,38 +259,10 @@ func GetNetworkNonServerNodeCount(networkName string) (int, error) {
return count, nil
}
//Checks to see if access key is valid
//Does so by checking against all keys and seeing if any have the same value
//may want to hash values before comparing...consider this
//TODO: No error handling!!!!
// IsKeyValid - check if key is valid
func IsKeyValid(networkname string, keyvalue string) bool {
network, _ := GetParentNetwork(networkname)
var key models.AccessKey
foundkey := false
isvalid := false
for i := len(network.AccessKeys) - 1; i >= 0; i-- {
currentkey := network.AccessKeys[i]
if currentkey.Value == keyvalue {
key = currentkey
foundkey = true
}
}
if foundkey {
if key.Uses > 0 {
isvalid = true
}
}
return isvalid
}
// IsKeyValidGlobal - checks if a key is valid globally
func IsKeyValidGlobal(keyvalue string) bool {
networks, _ := models.GetNetworks()
networks, _ := logic.GetNetworks()
var key models.AccessKey
foundkey := false
isvalid := false
@@ -478,43 +292,10 @@ func IsKeyValidGlobal(keyvalue string) bool {
//Should probably just be GetNetwork. kind of a dumb name.
//Used in contexts where it's not the Parent network.
// GetParentNetwork - get parent network
func GetParentNetwork(networkname string) (models.Network, error) {
var network models.Network
networkData, err := database.FetchRecord(database.NETWORKS_TABLE_NAME, networkname)
if err != nil {
return network, err
}
if err = json.Unmarshal([]byte(networkData), &network); err != nil {
return models.Network{}, err
}
return network, nil
}
// IsIpNet - checks if valid ip
func IsIpNet(host string) bool {
return net.ParseIP(host) != nil
}
//Similar to above but checks if Cidr range is valid
//At least this guy's got some print statements
//still not good error handling
// IsIpCIDR - IsIpCIDR
func IsIpCIDR(host string) bool {
ip, ipnet, err := net.ParseCIDR(host)
if err != nil {
fmt.Println(err)
fmt.Println("Address Range is not valid!")
return false
}
return ip != nil && ipnet != nil
}
//This checks to make sure a network name is valid.
//Switch to REGEX?
@@ -557,59 +338,6 @@ func NameInNodeCharSet(name string) bool {
return true
}
//This returns a node based on its mac address.
//The mac address acts as the Unique ID for nodes.
//Is this a dumb thing to do? I thought it was cool but maybe it's dumb.
//It doesn't really provide a tangible benefit over a random ID
// GetNodeByMacAddress - gets a node by mac address
func GetNodeByMacAddress(network string, macaddress string) (models.Node, error) {
var node models.Node
key, err := GetRecordKey(macaddress, network)
if err != nil {
return node, err
}
record, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
if err != nil {
return models.Node{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.Node{}, err
}
node.SetDefaults()
return node, nil
}
// GetDeletedNodeByMacAddress - get a deleted node
func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node, error) {
var node models.Node
key, err := GetRecordKey(macaddress, network)
if err != nil {
return node, err
}
record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
if err != nil {
return models.Node{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.Node{}, err
}
node.SetDefaults()
return node, nil
}
// RemoveDeletedNode - remove deleted node
func RemoveDeletedNode(nodeid string) bool {
return database.DeleteRecord(database.DELETED_NODES_TABLE_NAME, nodeid) == nil
@@ -668,82 +396,6 @@ func GetAllExtClients() ([]models.ExtClient, error) {
return extclients, nil
}
//This returns a unique address for a node to use
//it iterates through the list of IP's in the subnet
//and checks against all nodes to see if it's taken, until it finds one.
//TODO: We do not handle a case where we run out of addresses.
//We will need to handle that eventually
// UniqueAddress - see if address is unique
func UniqueAddress(networkName string) (string, error) {
var network models.Network
network, err := GetParentNetwork(networkName)
if err != nil {
fmt.Println("UniqueAddress encountered an error")
return "666", err
}
offset := true
ip, ipnet, err := net.ParseCIDR(network.AddressRange)
if err != nil {
fmt.Println("UniqueAddress encountered an error")
return "666", err
}
for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); Inc(ip) {
if offset {
offset = false
continue
}
if networkName == "comms" {
if IsIPUnique(networkName, ip.String(), database.INT_CLIENTS_TABLE_NAME, false) {
return ip.String(), err
}
} else {
if IsIPUnique(networkName, ip.String(), database.NODES_TABLE_NAME, false) && IsIPUnique(networkName, ip.String(), database.EXT_CLIENT_TABLE_NAME, false) {
return ip.String(), err
}
}
}
//TODO
err1 := errors.New("ERROR: No unique addresses available. Check network subnet.")
return "W1R3: NO UNIQUE ADDRESSES AVAILABLE", err1
}
// UniqueAddress6 - see if ipv6 address is unique
func UniqueAddress6(networkName string) (string, error) {
var network models.Network
network, err := GetParentNetwork(networkName)
if err != nil {
fmt.Println("Network Not Found")
return "", err
}
if network.IsDualStack == "no" {
return "", nil
}
offset := true
ip, ipnet, err := net.ParseCIDR(network.AddressRange6)
if err != nil {
fmt.Println("UniqueAddress6 encountered an error")
return "666", err
}
for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); Inc(ip) {
if offset {
offset = false
continue
}
if IsIPUnique(networkName, ip.String(), database.NODES_TABLE_NAME, true) {
return ip.String(), err
}
}
//TODO
err1 := errors.New("ERROR: No unique addresses available. Check network subnet.")
return "W1R3: NO UNIQUE ADDRESSES AVAILABLE", err1
}
// GenKey - generates access key
func GenKey() string {
@@ -810,39 +462,6 @@ func IsIPUnique(network string, ip string, tableName string, isIpv6 bool) bool {
return isunique
}
//called once key has been used by createNode
//reduces value by one and deletes if necessary
// DecrimentKey - decriments key uses
func DecrimentKey(networkName string, keyvalue string) {
var network models.Network
network, err := GetParentNetwork(networkName)
if err != nil {
return
}
for i := len(network.AccessKeys) - 1; i >= 0; i-- {
currentkey := network.AccessKeys[i]
if currentkey.Value == keyvalue {
network.AccessKeys[i].Uses--
if network.AccessKeys[i].Uses < 1 {
network.AccessKeys = append(network.AccessKeys[:i],
network.AccessKeys[i+1:]...)
break
}
}
}
if newNetworkData, err := json.Marshal(&network); err != nil {
PrintUserLog(models.NODE_SERVER_NAME, "failed to decrement key", 2)
return
} else {
database.Insert(network.NetID, string(newNetworkData), database.NETWORKS_TABLE_NAME)
}
}
// DeleteKey - deletes a key
func DeleteKey(network models.Network, i int) {
@@ -855,13 +474,3 @@ func DeleteKey(network models.Network, i int) {
database.Insert(network.NetID, string(networkData), database.NETWORKS_TABLE_NAME)
}
}
// Inc - increments an IP
func Inc(ip net.IP) {
for j := len(ip) - 1; j >= 0; j-- {
ip[j]++
if ip[j] > 0 {
break
}
}
}

38
functions/local.go
View File

@@ -1,10 +1,12 @@
package functions
import (
"io/ioutil"
"os"
"github.com/gravitl/netmaker/logic"
)
// FileExists - checks if file exists
func FileExists(f string) bool {
info, err := os.Stat(f)
if os.IsNotExist(err) {
@@ -13,6 +15,7 @@ func FileExists(f string) bool {
return !info.IsDir()
}
// SetDNSDir - sets the dns directory of the system
func SetDNSDir() error {
dir, err := os.Getwd()
if err != nil {
@@ -27,7 +30,7 @@ func SetDNSDir() error {
}
_, err = os.Stat(dir + "/config/dnsconfig/Corefile")
if os.IsNotExist(err) {
err = SetCorefile(".")
err = logic.SetCorefile(".")
if err != nil {
PrintUserLog("", err.Error(), 0)
}
@@ -41,34 +44,3 @@ func SetDNSDir() error {
}
return nil
}
func SetCorefile(domains string) error {
dir, err := os.Getwd()
if err != nil {
return err
}
_, err = os.Stat(dir + "/config/dnsconfig")
if os.IsNotExist(err) {
os.Mkdir(dir+"/config/dnsconfig", 744)
} else if err != nil {
PrintUserLog("", "couldnt find or create /config/dnsconfig", 0)
return err
}
corefile := domains + ` {
reload 15s
hosts /root/dnsconfig/netmaker.hosts {
fallthrough
}
forward . 8.8.8.8 8.8.4.4
log
}
`
corebytes := []byte(corefile)
err = ioutil.WriteFile(dir+"/config/dnsconfig/Corefile", corebytes, 0644)
if err != nil {
return err
}
return err
}

62
logic/accesskeys.go Normal file
View File

@@ -0,0 +1,62 @@
package logic
import (
"encoding/json"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/models"
)
// DecrimentKey - decriments key uses
func DecrimentKey(networkName string, keyvalue string) {
var network models.Network
network, err := GetParentNetwork(networkName)
if err != nil {
return
}
for i := len(network.AccessKeys) - 1; i >= 0; i-- {
currentkey := network.AccessKeys[i]
if currentkey.Value == keyvalue {
network.AccessKeys[i].Uses--
if network.AccessKeys[i].Uses < 1 {
network.AccessKeys = append(network.AccessKeys[:i],
network.AccessKeys[i+1:]...)
break
}
}
}
if newNetworkData, err := json.Marshal(&network); err != nil {
Log("failed to decrement key", 2)
return
} else {
database.Insert(network.NetID, string(newNetworkData), database.NETWORKS_TABLE_NAME)
}
}
// IsKeyValid - check if key is valid
func IsKeyValid(networkname string, keyvalue string) bool {
network, _ := GetParentNetwork(networkname)
var key models.AccessKey
foundkey := false
isvalid := false
for i := len(network.AccessKeys) - 1; i >= 0; i-- {
currentkey := network.AccessKeys[i]
if currentkey.Value == keyvalue {
key = currentkey
foundkey = true
}
}
if foundkey {
if key.Uses > 0 {
isvalid = true
}
}
return isvalid
}

41
dnslogic/dns.go → logic/dns.go
View File

@@ -1,10 +1,11 @@
package dnslogic
package logic
import (
"encoding/json"
"io/ioutil"
"os"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/servercfg"
"github.com/txn2/txeh"
@@ -14,7 +15,7 @@ import (
func SetDNS() error {
hostfile := txeh.Hosts{}
var corefilestring string
networks, err := models.GetNetworks()
networks, err := GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
return err
}
@@ -38,7 +39,7 @@ func SetDNS() error {
return err
}
if servercfg.IsSplitDNS() {
err = functions.SetCorefile(corefilestring)
err = SetCorefile(corefilestring)
}
return err
}
@@ -106,3 +107,35 @@ func GetCustomDNS(network string) ([]models.DNSEntry, error) {
return dns, err
}
// SetCorefile - sets the core file of the system
func SetCorefile(domains string) error {
dir, err := os.Getwd()
if err != nil {
return err
}
_, err = os.Stat(dir + "/config/dnsconfig")
if os.IsNotExist(err) {
os.Mkdir(dir+"/config/dnsconfig", 744)
} else if err != nil {
Log("couldnt find or create /config/dnsconfig", 0)
return err
}
corefile := domains + ` {
reload 15s
hosts /root/dnsconfig/netmaker.hosts {
fallthrough
}
forward . 8.8.8.8 8.8.4.4
log
}
`
corebytes := []byte(corefile)
err = ioutil.WriteFile(dir+"/config/dnsconfig/Corefile", corebytes, 0644)
if err != nil {
return err
}
return err
}

31
logic/extpeers.go
View File

@@ -4,7 +4,6 @@ import (
"encoding/json"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/models"
)
@@ -23,12 +22,12 @@ func GetExtPeersList(macaddress string, networkName string) ([]models.ExtPeersRe
var extClient models.ExtClient
err = json.Unmarshal([]byte(value), &peer)
if err != nil {
functions.PrintUserLog(models.NODE_SERVER_NAME, "failed to unmarshal peer", 2)
Log("failed to unmarshal peer when getting ext peer list", 2)
continue
}
err = json.Unmarshal([]byte(value), &extClient)
if err != nil {
functions.PrintUserLog(models.NODE_SERVER_NAME, "failed to unmarshal ext client", 2)
Log("failed to unmarshal ext client", 2)
continue
}
if extClient.Network == networkName && extClient.IngressGatewayID == macaddress {
@@ -37,3 +36,29 @@ func GetExtPeersList(macaddress string, networkName string) ([]models.ExtPeersRe
}
return peers, err
}
// ExtClient.GetEgressRangesOnNetwork - returns the egress ranges on network of ext client
func GetEgressRangesOnNetwork(client *models.ExtClient) ([]string, error) {
var result []string
nodesData, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
return []string{}, err
}
for _, nodeData := range nodesData {
var currentNode models.Node
if err = json.Unmarshal([]byte(nodeData), &currentNode); err != nil {
continue
}
if currentNode.Network != client.Network {
continue
}
if currentNode.IsEgressGateway == "yes" { // add the egress gateway range(s) to the result
if len(currentNode.EgressGatewayRanges) > 0 {
result = append(result, currentNode.EgressGatewayRanges...)
}
}
}
return result, nil
}

2
functions/jwt.go → logic/jwts.go
View File

@@ -1,4 +1,4 @@
package functions
package logic
import (
"errors"

117
logic/network.go
View File

@@ -1,117 +0,0 @@
package logic
import (
"net"
"os/exec"
"strings"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/netclient/ncutils"
)
// CheckNetworkExists - checks i a network exists for this netmaker instance
func CheckNetworkExists(network string) bool {
var _, err = database.FetchRecord(database.NETWORKS_TABLE_NAME, network)
return err == nil
}
// GetLocalIP - gets the local ip
func GetLocalIP(node models.Node) string {
var local string
ifaces, err := net.Interfaces()
if err != nil {
return local
}
_, localrange, err := net.ParseCIDR(node.LocalRange)
if err != nil {
return local
}
found := false
for _, i := range ifaces {
if i.Flags&net.FlagUp == 0 {
continue // interface down
}
if i.Flags&net.FlagLoopback != 0 {
continue // loopback interface
}
addrs, err := i.Addrs()
if err != nil {
return local
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
if !found {
ip = v.IP
local = ip.String()
if node.IsLocal == "yes" {
found = localrange.Contains(ip)
} else {
found = true
}
}
case *net.IPAddr:
if !found {
ip = v.IP
local = ip.String()
if node.IsLocal == "yes" {
found = localrange.Contains(ip)
} else {
found = true
}
}
}
}
}
return local
}
// == Private ==
func deleteInterface(ifacename string, postdown string) error {
var err error
if !ncutils.IsKernel() {
err = RemoveConf(ifacename, true)
} else {
ipExec, errN := exec.LookPath("ip")
err = errN
if err != nil {
ncutils.PrintLog(err.Error(), 1)
}
_, err = ncutils.RunCmd(ipExec+" link del "+ifacename, false)
if postdown != "" {
runcmds := strings.Split(postdown, "; ")
err = ncutils.RunCmds(runcmds, true)
}
}
return err
}
func isInterfacePresent(iface string, address string) (string, bool) {
var interfaces []net.Interface
var err error
interfaces, err = net.Interfaces()
if err != nil {
Log("ERROR: could not read interfaces", 0)
return "", true
}
for _, currIface := range interfaces {
var currAddrs []net.Addr
currAddrs, err = currIface.Addrs()
if err != nil || len(currAddrs) == 0 {
continue
}
for _, addr := range currAddrs {
if strings.Contains(addr.String(), address) && currIface.Name != iface {
return currIface.Name, false
}
}
}
return "", true
}

437
logic/networks.go Normal file
View File

@@ -0,0 +1,437 @@
package logic
import (
"encoding/json"
"errors"
"fmt"
"net"
"os/exec"
"strings"
"github.com/go-playground/validator/v10"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/netclient/ncutils"
"github.com/gravitl/netmaker/validation"
)
// GetNetworks - returns all networks from database
func GetNetworks() ([]models.Network, error) {
var networks []models.Network
collection, err := database.FetchRecords(database.NETWORKS_TABLE_NAME)
if err != nil {
return networks, err
}
for _, value := range collection {
var network models.Network
if err := json.Unmarshal([]byte(value), &network); err != nil {
return networks, err
}
// add network our array
networks = append(networks, network)
}
return networks, err
}
// GetParentNetwork - get parent network
func GetParentNetwork(networkname string) (models.Network, error) {
var network models.Network
networkData, err := database.FetchRecord(database.NETWORKS_TABLE_NAME, networkname)
if err != nil {
return network, err
}
if err = json.Unmarshal([]byte(networkData), &network); err != nil {
return models.Network{}, err
}
return network, nil
}
// UniqueAddress - see if address is unique
func UniqueAddress(networkName string) (string, error) {
var network models.Network
network, err := GetParentNetwork(networkName)
if err != nil {
fmt.Println("UniqueAddress encountered an error")
return "666", err
}
offset := true
ip, ipnet, err := net.ParseCIDR(network.AddressRange)
if err != nil {
fmt.Println("UniqueAddress encountered an error")
return "666", err
}
for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); Inc(ip) {
if offset {
offset = false
continue
}
if networkName == "comms" {
if IsIPUnique(networkName, ip.String(), database.INT_CLIENTS_TABLE_NAME, false) {
return ip.String(), err
}
} else {
if IsIPUnique(networkName, ip.String(), database.NODES_TABLE_NAME, false) && IsIPUnique(networkName, ip.String(), database.EXT_CLIENT_TABLE_NAME, false) {
return ip.String(), err
}
}
}
//TODO
err1 := errors.New("ERROR: No unique addresses available. Check network subnet.")
return "W1R3: NO UNIQUE ADDRESSES AVAILABLE", err1
}
// UniqueAddress6 - see if ipv6 address is unique
func UniqueAddress6(networkName string) (string, error) {
var network models.Network
network, err := GetParentNetwork(networkName)
if err != nil {
fmt.Println("Network Not Found")
return "", err
}
if network.IsDualStack == "no" {
return "", nil
}
offset := true
ip, ipnet, err := net.ParseCIDR(network.AddressRange6)
if err != nil {
fmt.Println("UniqueAddress6 encountered an error")
return "666", err
}
for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); Inc(ip) {
if offset {
offset = false
continue
}
if IsIPUnique(networkName, ip.String(), database.NODES_TABLE_NAME, true) {
return ip.String(), err
}
}
//TODO
err1 := errors.New("ERROR: No unique addresses available. Check network subnet.")
return "W1R3: NO UNIQUE ADDRESSES AVAILABLE", err1
}
// GetLocalIP - gets the local ip
func GetLocalIP(node models.Node) string {
var local string
ifaces, err := net.Interfaces()
if err != nil {
return local
}
_, localrange, err := net.ParseCIDR(node.LocalRange)
if err != nil {
return local
}
found := false
for _, i := range ifaces {
if i.Flags&net.FlagUp == 0 {
continue // interface down
}
if i.Flags&net.FlagLoopback != 0 {
continue // loopback interface
}
addrs, err := i.Addrs()
if err != nil {
return local
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
if !found {
ip = v.IP
local = ip.String()
if node.IsLocal == "yes" {
found = localrange.Contains(ip)
} else {
found = true
}
}
case *net.IPAddr:
if !found {
ip = v.IP
local = ip.String()
if node.IsLocal == "yes" {
found = localrange.Contains(ip)
} else {
found = true
}
}
}
}
}
return local
}
// UpdateNetworkLocalAddresses - updates network localaddresses
func UpdateNetworkLocalAddresses(networkName string) error {
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
return err
}
for _, value := range collection {
var node models.Node
err := json.Unmarshal([]byte(value), &node)
if err != nil {
fmt.Println("error in node address assignment!")
return err
}
if node.Network == networkName {
ipaddr, iperr := UniqueAddress(networkName)
if iperr != nil {
fmt.Println("error in node address assignment!")
return iperr
}
node.Address = ipaddr
newNodeData, err := json.Marshal(&node)
if err != nil {
fmt.Println("error in node address assignment!")
return err
}
node.SetID()
database.Insert(node.ID, string(newNodeData), database.NODES_TABLE_NAME)
}
}
return nil
}
// UpdateNetworkNodeAddresses - updates network node addresses
func UpdateNetworkNodeAddresses(networkName string) error {
collections, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
return err
}
for _, value := range collections {
var node models.Node
err := json.Unmarshal([]byte(value), &node)
if err != nil {
fmt.Println("error in node address assignment!")
return err
}
if node.Network == networkName {
ipaddr, iperr := UniqueAddress(networkName)
if iperr != nil {
fmt.Println("error in node address assignment!")
return iperr
}
node.Address = ipaddr
node.PullChanges = "yes"
data, err := json.Marshal(&node)
if err != nil {
return err
}
node.SetID()
database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
}
}
return nil
}
// IsNetworkDisplayNameUnique - checks if displayname is unique from other networks
func IsNetworkDisplayNameUnique(network *models.Network) (bool, error) {
isunique := true
records, err := GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
return false, err
}
for i := 0; i < len(records); i++ {
if network.NetID == records[i].DisplayName {
isunique = false
}
}
return isunique, nil
}
// IsNetworkNameUnique - checks to see if any other networks have the same name (id)
func IsNetworkNameUnique(network *models.Network) (bool, error) {
isunique := true
dbs, err := GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
return false, err
}
for i := 0; i < len(dbs); i++ {
if network.NetID == dbs[i].NetID {
isunique = false
}
}
return isunique, nil
}
// UpdateNetwork - updates a network with another network's fields
func UpdateNetwork(currentNetwork *models.Network, newNetwork *models.Network) (bool, bool, error) {
if err := ValidateNetwork(newNetwork, true); err != nil {
return false, false, err
}
if newNetwork.NetID == currentNetwork.NetID {
hasrangeupdate := newNetwork.AddressRange != currentNetwork.AddressRange
localrangeupdate := newNetwork.LocalRange != currentNetwork.LocalRange
data, err := json.Marshal(newNetwork)
if err != nil {
return false, false, err
}
newNetwork.SetNetworkLastModified()
err = database.Insert(newNetwork.NetID, string(data), database.NETWORKS_TABLE_NAME)
return hasrangeupdate, localrangeupdate, err
}
// copy values
return false, false, errors.New("failed to update network " + newNetwork.NetID + ", cannot change netid.")
}
// // SetNetworkNodesLastModified - sets network nodes last modified time
// func SetNetworkNodesLastModified(network *models.Network) error {
// timestamp := time.Now().Unix()
// network.NodesLastModified = timestamp
// data, err := json.Marshal(&network)
// if err != nil {
// return err
// }
// err = database.Insert(network.NetID, string(data), database.NETWORKS_TABLE_NAME)
// if err != nil {
// return err
// }
// return nil
// }
// GetNetwork - gets a network from database
func GetNetwork(networkname string) (models.Network, error) {
var network models.Network
networkData, err := database.FetchRecord(database.NETWORKS_TABLE_NAME, networkname)
if err != nil {
return network, err
}
if err = json.Unmarshal([]byte(networkData), &network); err != nil {
return models.Network{}, err
}
return network, nil
}
// Network.NetIDInNetworkCharSet - checks if a netid of a network uses valid characters
func NetIDInNetworkCharSet(network *models.Network) bool {
charset := "abcdefghijklmnopqrstuvwxyz1234567890-_."
for _, char := range network.NetID {
if !strings.Contains(charset, strings.ToLower(string(char))) {
return false
}
}
return true
}
// Network.Validate - validates fields of an network struct
func ValidateNetwork(network *models.Network, isUpdate bool) error {
v := validator.New()
_ = v.RegisterValidation("netid_valid", func(fl validator.FieldLevel) bool {
inCharSet := NetIDInNetworkCharSet(network)
if isUpdate {
return inCharSet
}
isFieldUnique, _ := IsNetworkNameUnique(network)
return isFieldUnique && inCharSet
})
//
_ = v.RegisterValidation("displayname_valid", func(fl validator.FieldLevel) bool {
isFieldUnique, _ := IsNetworkDisplayNameUnique(network)
inCharSet := network.DisplayNameInNetworkCharSet()
if isUpdate {
return inCharSet
}
return isFieldUnique && inCharSet
})
_ = v.RegisterValidation("checkyesorno", func(fl validator.FieldLevel) bool {
return validation.CheckYesOrNo(fl)
})
err := v.Struct(network)
if err != nil {
for _, e := range err.(validator.ValidationErrors) {
fmt.Println(e)
}
}
return err
}
// == Private ==
func deleteInterface(ifacename string, postdown string) error {
var err error
if !ncutils.IsKernel() {
err = RemoveConf(ifacename, true)
} else {
ipExec, errN := exec.LookPath("ip")
err = errN
if err != nil {
ncutils.PrintLog(err.Error(), 1)
}
_, err = ncutils.RunCmd(ipExec+" link del "+ifacename, false)
if postdown != "" {
runcmds := strings.Split(postdown, "; ")
err = ncutils.RunCmds(runcmds, true)
}
}
return err
}
func isInterfacePresent(iface string, address string) (string, bool) {
var interfaces []net.Interface
var err error
interfaces, err = net.Interfaces()
if err != nil {
Log("ERROR: could not read interfaces", 0)
return "", true
}
for _, currIface := range interfaces {
var currAddrs []net.Addr
currAddrs, err = currIface.Addrs()
if err != nil || len(currAddrs) == 0 {
continue
}
for _, addr := range currAddrs {
if strings.Contains(addr.String(), address) && currIface.Name != iface {
return currIface.Name, false
}
}
}
return "", true
}

265
logic/nodes.go
View File

@@ -2,12 +2,15 @@ package logic
import (
"encoding/json"
"errors"
"fmt"
"sort"
"time"
"github.com/go-playground/validator/v10"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/validation"
)
// GetNetworkNodes - gets the nodes of a network
@@ -80,7 +83,7 @@ func GetPeers(node models.Node) ([]models.Node, error) {
func IsLeader(node *models.Node) bool {
nodes, err := GetSortedNetworkServerNodes(node.Network)
if err != nil {
functions.PrintUserLog("", "ERROR: COULD NOT RETRIEVE SERVER NODES. THIS WILL BREAK HOLE PUNCHING.", 0)
Log("ERROR: COULD NOT RETRIEVE SERVER NODES. THIS WILL BREAK HOLE PUNCHING.", 0)
return false
}
for _, n := range nodes {
@@ -90,3 +93,261 @@ func IsLeader(node *models.Node) bool {
}
return len(nodes) <= 1 || nodes[1].Address == node.Address
}
// == DB related functions ==
// UpdateNode - takes a node and updates another node with it's values
func UpdateNode(currentNode *models.Node, newNode *models.Node) error {
newNode.Fill(currentNode)
if err := ValidateNode(newNode, true); err != nil {
return err
}
newNode.SetID()
if newNode.ID == currentNode.ID {
newNode.SetLastModified()
if data, err := json.Marshal(newNode); err != nil {
return err
} else {
return database.Insert(newNode.ID, string(data), database.NODES_TABLE_NAME)
}
}
return fmt.Errorf("failed to update node " + newNode.MacAddress + ", cannot change macaddress.")
}
func IsNodeIDUnique(node *models.Node) (bool, error) {
_, err := database.FetchRecord(database.NODES_TABLE_NAME, node.ID)
return database.IsEmptyRecord(err), err
}
func ValidateNode(node *models.Node, isUpdate bool) error {
v := validator.New()
_ = v.RegisterValidation("macaddress_unique", func(fl validator.FieldLevel) bool {
if isUpdate {
return true
}
isFieldUnique, _ := IsNodeIDUnique(node)
return isFieldUnique
})
_ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
_, err := GetNetworkByNode(node)
return err == nil
})
_ = v.RegisterValidation("in_charset", func(fl validator.FieldLevel) bool {
isgood := node.NameInNodeCharSet()
return isgood
})
_ = v.RegisterValidation("checkyesorno", func(fl validator.FieldLevel) bool {
return validation.CheckYesOrNo(fl)
})
err := v.Struct(node)
return err
}
// GetAllNodes - returns all nodes in the DB
func GetAllNodes() ([]models.Node, error) {
var nodes []models.Node
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
if database.IsEmptyRecord(err) {
return []models.Node{}, nil
}
return []models.Node{}, err
}
for _, value := range collection {
var node models.Node
if err := json.Unmarshal([]byte(value), &node); err != nil {
return []models.Node{}, err
}
// add node to our array
nodes = append(nodes, node)
}
return nodes, nil
}
// CheckIsServer - check if a node is the server node
func CheckIsServer(node *models.Node) 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
if err := json.Unmarshal([]byte(value), &tmpNode); err != nil {
continue
}
if tmpNode.Network == node.Network && tmpNode.MacAddress != node.MacAddress {
return false
}
}
return true
}
// GetNetworkByNode - gets the network model from a node
func GetNetworkByNode(node *models.Node) (models.Network, error) {
var network models.Network
networkData, err := database.FetchRecord(database.NETWORKS_TABLE_NAME, node.Network)
if err != nil {
return network, err
}
if err = json.Unmarshal([]byte(networkData), &network); err != nil {
return models.Network{}, err
}
return network, nil
}
// SetNodeDefaults - sets the defaults of a node to avoid empty fields
func SetNodeDefaults(node *models.Node) {
//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)
node.ExpirationDateTime = time.Now().Unix() + models.TEN_YEARS_IN_SECONDS
if node.ListenPort == 0 {
node.ListenPort = parentNetwork.DefaultListenPort
}
if node.SaveConfig == "" {
if parentNetwork.DefaultSaveConfig != "" {
node.SaveConfig = parentNetwork.DefaultSaveConfig
} else {
node.SaveConfig = "yes"
}
}
if node.Interface == "" {
node.Interface = parentNetwork.DefaultInterface
}
if node.PersistentKeepalive == 0 {
node.PersistentKeepalive = parentNetwork.DefaultKeepalive
}
if node.PostUp == "" {
postup := parentNetwork.DefaultPostUp
node.PostUp = postup
}
if node.IsStatic == "" {
node.IsStatic = "no"
}
if node.UDPHolePunch == "" {
node.UDPHolePunch = parentNetwork.DefaultUDPHolePunch
if node.UDPHolePunch == "" {
node.UDPHolePunch = "yes"
}
}
// == Parent Network settings ==
if node.IsDualStack == "" {
node.IsDualStack = parentNetwork.IsDualStack
}
if node.MTU == 0 {
node.MTU = parentNetwork.DefaultMTU
}
// == node defaults if not set by parent ==
node.SetIPForwardingDefault()
node.SetDNSOnDefault()
node.SetIsLocalDefault()
node.SetIsDualStackDefault()
node.SetLastModified()
node.SetDefaultName()
node.SetLastCheckIn()
node.SetLastPeerUpdate()
node.SetRoamingDefault()
node.SetPullChangesDefault()
node.SetDefaultAction()
node.SetID()
node.SetIsServerDefault()
node.SetIsStaticDefault()
node.SetDefaultEgressGateway()
node.SetDefaultIngressGateway()
node.SetDefaulIsPending()
node.SetDefaultMTU()
node.SetDefaultIsRelayed()
node.SetDefaultIsRelay()
node.KeyUpdateTimeStamp = time.Now().Unix()
}
// GetRecordKey - get record key
func GetRecordKey(id string, network string) (string, error) {
if id == "" || network == "" {
return "", errors.New("unable to get record key")
}
return id + "###" + network, nil
}
// GetNodeByMacAddress - gets a node by mac address
func GetNodeByMacAddress(network string, macaddress string) (models.Node, error) {
var node models.Node
key, err := GetRecordKey(macaddress, network)
if err != nil {
return node, err
}
record, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
if err != nil {
return models.Node{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.Node{}, err
}
SetNodeDefaults(&node)
return node, nil
}
// GetDeletedNodeByMacAddress - get a deleted node
func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node, error) {
var node models.Node
key, err := GetRecordKey(macaddress, network)
if err != nil {
return node, err
}
record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
if err != nil {
return models.Node{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.Node{}, err
}
SetNodeDefaults(&node)
return node, nil
}
// GetNodeRelay - gets the relay node of a given network
func GetNodeRelay(network string, relayedNodeAddr string) (models.Node, error) {
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
var relay models.Node
if err != nil {
if database.IsEmptyRecord(err) {
return relay, nil
}
Log(err.Error(), 2)
return relay, err
}
for _, value := range collection {
err := json.Unmarshal([]byte(value), &relay)
if err != nil {
Log(err.Error(), 2)
continue
}
if relay.IsRelay == "yes" {
for _, addr := range relay.RelayAddrs {
if addr == relayedNodeAddr {
return relay, nil
}
}
}
}
return relay, errors.New("could not find relay for node " + relayedNodeAddr)
}

6
logic/server.go
View File

@@ -38,7 +38,7 @@ func ServerJoin(network string, serverID string, privateKey string) error {
MacAddress: serverID,
UDPHolePunch: "no",
}
node.SetDefaults()
SetNodeDefaults(node)
if servercfg.GetPlatform() == "Kubernetes" {
node.ListenPort = KUBERNETES_LISTEN_PORT
@@ -200,7 +200,7 @@ func ServerPull(mac string, network string, onErr bool) (*models.Node, error) {
return &serverNode, err
}
// handle server side update
if err = serverNode.Update(&serverNode); err != nil {
if err = UpdateNode(&serverNode, &serverNode); err != nil {
return &serverNode, err
}
} else {
@@ -227,7 +227,7 @@ func ServerPush(mac string, network string) error {
}
serverNode.OS = runtime.GOOS
serverNode.SetLastCheckIn()
return serverNode.Update(&serverNode)
return UpdateNode(&serverNode, &serverNode)
}
// ServerLeave - removes a server node

22
logic/users.go Normal file
View File

@@ -0,0 +1,22 @@
package logic
import (
"encoding/json"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/models"
)
// GetUser - gets a user
func GetUser(username string) (models.User, error) {
var user models.User
record, err := database.FetchRecord(database.USERS_TABLE_NAME, username)
if err != nil {
return user, err
}
if err = json.Unmarshal([]byte(record), &user); err != nil {
return models.User{}, err
}
return user, err
}

38
logic/util.go
View File

@@ -11,11 +11,8 @@ import (
"time"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/dnslogic"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/netclient/ncutils"
"github.com/gravitl/netmaker/relay"
"github.com/gravitl/netmaker/servercfg"
"golang.org/x/crypto/bcrypt"
)
@@ -37,11 +34,10 @@ func CheckEndpoint(endpoint string) bool {
func SetNetworkServerPeers(node *models.Node) {
if currentPeersList, err := GetSystemPeers(node); err == nil {
if database.SetPeers(currentPeersList, node.Network) {
functions.PrintUserLog(models.NODE_SERVER_NAME, "set new peers on network "+node.Network, 1)
Log("set new peers on network "+node.Network, 1)
}
} else {
functions.PrintUserLog(models.NODE_SERVER_NAME, "could not set peers on network "+node.Network, 1)
functions.PrintUserLog(models.NODE_SERVER_NAME, err.Error(), 1)
Log("could not set peers on network "+node.Network+"\n"+err.Error(), 1)
}
}
@@ -74,7 +70,7 @@ func DeleteNode(node *models.Node, exterminate bool) error {
return err
}
if servercfg.IsDNSMode() {
err = dnslogic.SetDNS()
err = SetDNS()
}
return removeLocalServer(node)
}
@@ -102,26 +98,26 @@ func CreateNode(node models.Node, networkName string) (models.Node, error) {
node.DNSOn = "no"
}
}
node.SetDefaults()
node.Address, err = functions.UniqueAddress(networkName)
SetNodeDefaults(&node)
node.Address, err = UniqueAddress(networkName)
if err != nil {
return node, err
}
node.Address6, err = functions.UniqueAddress6(networkName)
node.Address6, err = UniqueAddress6(networkName)
if err != nil {
return node, err
}
//Create a JWT for the node
tokenString, _ := functions.CreateJWT(node.MacAddress, networkName)
tokenString, _ := CreateJWT(node.MacAddress, networkName)
if tokenString == "" {
//returnErrorResponse(w, r, errorResponse)
return node, err
}
err = node.Validate(false)
err = ValidateNode(&node, false)
if err != nil {
return node, err
}
key, err := functions.GetRecordKey(node.MacAddress, node.Network)
key, err := GetRecordKey(node.MacAddress, node.Network)
if err != nil {
return node, err
}
@@ -134,11 +130,11 @@ func CreateNode(node models.Node, networkName string) (models.Node, error) {
return node, err
}
if node.IsPending != "yes" {
functions.DecrimentKey(node.Network, node.AccessKey)
DecrimentKey(node.Network, node.AccessKey)
}
SetNetworkNodesLastModified(node.Network)
if servercfg.IsDNSMode() {
err = dnslogic.SetDNS()
err = SetDNS()
}
return node, err
}
@@ -148,7 +144,7 @@ func SetNetworkNodesLastModified(networkName string) error {
timestamp := time.Now().Unix()
network, err := functions.GetParentNetwork(networkName)
network, err := GetParentNetwork(networkName)
if err != nil {
return err
}
@@ -168,7 +164,7 @@ func SetNetworkNodesLastModified(networkName string) error {
func GetNode(macaddress string, network string) (models.Node, error) {
var node models.Node
key, err := functions.GetRecordKey(macaddress, network)
key, err := GetRecordKey(macaddress, network)
if err != nil {
return node, err
}
@@ -183,7 +179,7 @@ func GetNode(macaddress string, network string) (models.Node, error) {
if err = json.Unmarshal([]byte(data), &node); err != nil {
return node, err
}
node.SetDefaults()
SetNodeDefaults(&node)
return node, err
}
@@ -231,7 +227,7 @@ func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error
}
}
if node.IsRelay == "yes" {
network, err := models.GetNetwork(networkName)
network, err := GetNetwork(networkName)
if err == nil {
peer.AllowedIPs = append(peer.AllowedIPs, network.AddressRange)
} else {
@@ -254,10 +250,10 @@ func GetPeersList(networkName string, excludeRelayed bool, relayedNodeAddr strin
peers, err = GetNodePeers(networkName, excludeRelayed)
} else {
relayNode, err = relay.GetNodeRelay(networkName, relayedNodeAddr)
relayNode, err = GetNodeRelay(networkName, relayedNodeAddr)
if relayNode.Address != "" {
relayNode = setPeerInfo(relayNode)
network, err := models.GetNetwork(networkName)
network, err := GetNetwork(networkName)
if err == nil {
relayNode.AllowedIPs = append(relayNode.AllowedIPs, network.AddressRange)
} else {

3
main.go
View File

@@ -16,7 +16,6 @@ import (
"github.com/gravitl/netmaker/auth"
controller "github.com/gravitl/netmaker/controllers"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/dnslogic"
"github.com/gravitl/netmaker/functions"
nodepb "github.com/gravitl/netmaker/grpc"
"github.com/gravitl/netmaker/logic"
@@ -99,7 +98,7 @@ func startControllers() {
}
if servercfg.IsDNSMode() {
err := dnslogic.SetDNS()
err := logic.SetDNS()
if err != nil {
logic.Log("error occurred initializing DNS: "+err.Error(), 0)
}

32
models/extclient.go
View File

@@ -1,11 +1,5 @@
package models
import (
"encoding/json"
"github.com/gravitl/netmaker/database"
)
// ExtClient - struct for external clients
type ExtClient struct {
ClientID string `json:"clientid" bson:"clientid"`
@@ -18,29 +12,3 @@ type ExtClient struct {
IngressGatewayEndpoint string `json:"ingressgatewayendpoint" bson:"ingressgatewayendpoint"`
LastModified int64 `json:"lastmodified" bson:"lastmodified"`
}
// ExtClient.GetEgressRangesOnNetwork - returns the egress ranges on network of ext client
func (client *ExtClient) GetEgressRangesOnNetwork() ([]string, error) {
var result []string
nodesData, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
return []string{}, err
}
for _, nodeData := range nodesData {
var currentNode Node
if err = json.Unmarshal([]byte(nodeData), &currentNode); err != nil {
continue
}
if currentNode.Network != client.Network {
continue
}
if currentNode.IsEgressGateway == "yes" { // add the egress gateway range(s) to the result
if len(currentNode.EgressGatewayRanges) > 0 {
result = append(result, currentNode.EgressGatewayRanges...)
}
}
}
return result, nil
}

166
models/network.go
View File

@@ -1,14 +1,9 @@
package models
import (
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"github.com/go-playground/validator/v10"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/servercfg"
)
@@ -50,19 +45,6 @@ type SaveData struct { // put sensitive fields here
NetID string `json:"netid" bson:"netid" validate:"required,min=1,max=12,netid_valid"`
}
// Network.NetIDInNetworkCharSet - checks if a netid of a network uses valid characters
func (network *Network) NetIDInNetworkCharSet() bool {
charset := "abcdefghijklmnopqrstuvwxyz1234567890-_."
for _, char := range network.NetID {
if !strings.Contains(charset, strings.ToLower(string(char))) {
return false
}
}
return true
}
// Network.DisplayNameInNetworkCharSet - checks if displayname uses valid characters
func (network *Network) DisplayNameInNetworkCharSet() bool {
@@ -76,103 +58,6 @@ func (network *Network) DisplayNameInNetworkCharSet() bool {
return true
}
// GetNetworks - returns all networks from database
func GetNetworks() ([]Network, error) {
var networks []Network
collection, err := database.FetchRecords(database.NETWORKS_TABLE_NAME)
if err != nil {
return networks, err
}
for _, value := range collection {
var network Network
if err := json.Unmarshal([]byte(value), &network); err != nil {
return networks, err
}
// add network our array
networks = append(networks, network)
}
return networks, err
}
// Network.IsNetworkDisplayNameUnique - checks if displayname is unique from other networks
func (network *Network) IsNetworkDisplayNameUnique() (bool, error) {
isunique := true
records, err := GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
return false, err
}
for i := 0; i < len(records); i++ {
if network.NetID == records[i].DisplayName {
isunique = false
}
}
return isunique, nil
}
// Network.IsNetworkNameUnique - checks to see if any other networks have the same name (id)
func (network *Network) IsNetworkNameUnique() (bool, error) {
isunique := true
dbs, err := GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
return false, err
}
for i := 0; i < len(dbs); i++ {
if network.NetID == dbs[i].NetID {
isunique = false
}
}
return isunique, nil
}
// Network.Validate - validates fields of an network struct
func (network *Network) Validate(isUpdate bool) error {
v := validator.New()
_ = v.RegisterValidation("netid_valid", func(fl validator.FieldLevel) bool {
inCharSet := network.NetIDInNetworkCharSet()
if isUpdate {
return inCharSet
}
isFieldUnique, _ := network.IsNetworkNameUnique()
return isFieldUnique && inCharSet
})
//
_ = v.RegisterValidation("displayname_valid", func(fl validator.FieldLevel) bool {
isFieldUnique, _ := network.IsNetworkDisplayNameUnique()
inCharSet := network.DisplayNameInNetworkCharSet()
if isUpdate {
return inCharSet
}
return isFieldUnique && inCharSet
})
_ = v.RegisterValidation("checkyesorno", func(fl validator.FieldLevel) bool {
return CheckYesOrNo(fl)
})
err := v.Struct(network)
if err != nil {
for _, e := range err.(validator.ValidationErrors) {
fmt.Println(e)
}
}
return err
}
// Network.SetNodesLastModified - sets nodes last modified on network, depricated
func (network *Network) SetNodesLastModified() {
network.NodesLastModified = time.Now().Unix()
@@ -242,54 +127,3 @@ func (network *Network) SetDefaults() {
network.DefaultMTU = 1280
}
}
// Network.Update - updates a network with another network's fields
func (currentNetwork *Network) Update(newNetwork *Network) (bool, bool, error) {
if err := newNetwork.Validate(true); err != nil {
return false, false, err
}
if newNetwork.NetID == currentNetwork.NetID {
hasrangeupdate := newNetwork.AddressRange != currentNetwork.AddressRange
localrangeupdate := newNetwork.LocalRange != currentNetwork.LocalRange
data, err := json.Marshal(newNetwork)
if err != nil {
return false, false, err
}
newNetwork.SetNetworkLastModified()
err = database.Insert(newNetwork.NetID, string(data), database.NETWORKS_TABLE_NAME)
return hasrangeupdate, localrangeupdate, err
}
// copy values
return false, false, errors.New("failed to update network " + newNetwork.NetID + ", cannot change netid.")
}
// Network.SetNetworkNodesLastModified - sets network nodes last modified time
func (network *Network) SetNetworkNodesLastModified() error {
timestamp := time.Now().Unix()
network.NodesLastModified = timestamp
data, err := json.Marshal(&network)
if err != nil {
return err
}
err = database.Insert(network.NetID, string(data), database.NETWORKS_TABLE_NAME)
if err != nil {
return err
}
return nil
}
// GetNetwork - gets a network from database
func GetNetwork(networkname string) (Network, error) {
var network Network
networkData, err := database.FetchRecord(database.NETWORKS_TABLE_NAME, networkname)
if err != nil {
return network, err
}
if err = json.Unmarshal([]byte(networkData), &network); err != nil {
return Network{}, err
}
return network, nil
}

172
models/node.go
View File

@@ -2,15 +2,12 @@ package models
import (
"bytes"
"encoding/json"
"errors"
"math/rand"
"net"
"strings"
"time"
"github.com/go-playground/validator/v10"
"github.com/gravitl/netmaker/database"
"golang.org/x/crypto/bcrypt"
)
@@ -207,105 +204,6 @@ func (node *Node) SetDefaultName() {
}
}
func (node *Node) CheckIsServer() bool {
nodeData, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil && !database.IsEmptyRecord(err) {
return false
}
for _, value := range nodeData {
var tmpNode Node
if err := json.Unmarshal([]byte(value), &tmpNode); err != nil {
continue
}
if tmpNode.Network == node.Network && tmpNode.MacAddress != node.MacAddress {
return false
}
}
return true
}
func (node *Node) GetNetwork() (Network, error) {
var network Network
networkData, err := database.FetchRecord(database.NETWORKS_TABLE_NAME, node.Network)
if err != nil {
return network, err
}
if err = json.Unmarshal([]byte(networkData), &network); err != nil {
return Network{}, err
}
return network, nil
}
//TODO: I dont know why this exists
//This should exist on the node.go struct. I'm sure there was a reason?
func (node *Node) SetDefaults() {
//TODO: Maybe I should make Network a part of the node struct. Then we can just query the Network object for stuff.
parentNetwork, _ := node.GetNetwork()
node.ExpirationDateTime = time.Now().Unix() + TEN_YEARS_IN_SECONDS
if node.ListenPort == 0 {
node.ListenPort = parentNetwork.DefaultListenPort
}
if node.SaveConfig == "" {
if parentNetwork.DefaultSaveConfig != "" {
node.SaveConfig = parentNetwork.DefaultSaveConfig
} else {
node.SaveConfig = "yes"
}
}
if node.Interface == "" {
node.Interface = parentNetwork.DefaultInterface
}
if node.PersistentKeepalive == 0 {
node.PersistentKeepalive = parentNetwork.DefaultKeepalive
}
if node.PostUp == "" {
postup := parentNetwork.DefaultPostUp
node.PostUp = postup
}
if node.IsStatic == "" {
node.IsStatic = "no"
}
if node.UDPHolePunch == "" {
node.UDPHolePunch = parentNetwork.DefaultUDPHolePunch
if node.UDPHolePunch == "" {
node.UDPHolePunch = "yes"
}
}
// == Parent Network settings ==
if node.IsDualStack == "" {
node.IsDualStack = parentNetwork.IsDualStack
}
if node.MTU == 0 {
node.MTU = parentNetwork.DefaultMTU
}
// == node defaults if not set by parent ==
node.SetIPForwardingDefault()
node.SetDNSOnDefault()
node.SetIsLocalDefault()
node.SetIsDualStackDefault()
node.SetLastModified()
node.SetDefaultName()
node.SetLastCheckIn()
node.SetLastPeerUpdate()
node.SetRoamingDefault()
node.SetPullChangesDefault()
node.SetDefaultAction()
node.SetID()
node.SetIsServerDefault()
node.SetIsStaticDefault()
node.SetDefaultEgressGateway()
node.SetDefaultIngressGateway()
node.SetDefaulIsPending()
node.SetDefaultMTU()
node.SetDefaultIsRelayed()
node.SetDefaultIsRelay()
node.KeyUpdateTimeStamp = time.Now().Unix()
}
func (newNode *Node) Fill(currentNode *Node) {
if newNode.ID == "" {
newNode.ID = currentNode.ID
@@ -454,23 +352,6 @@ func (newNode *Node) Fill(currentNode *Node) {
}
}
func (currentNode *Node) Update(newNode *Node) error {
newNode.Fill(currentNode)
if err := newNode.Validate(true); err != nil {
return err
}
newNode.SetID()
if newNode.ID == currentNode.ID {
newNode.SetLastModified()
if data, err := json.Marshal(newNode); err != nil {
return err
} else {
return database.Insert(newNode.ID, string(data), database.NODES_TABLE_NAME)
}
}
return errors.New("failed to update node " + newNode.MacAddress + ", cannot change macaddress.")
}
func StringWithCharset(length int, charset string) string {
b := make([]byte, length)
for i := range b {
@@ -486,36 +367,6 @@ func IsIpv4Net(host string) bool {
return net.ParseIP(host) != nil
}
func (node *Node) Validate(isUpdate bool) error {
v := validator.New()
_ = v.RegisterValidation("macaddress_unique", func(fl validator.FieldLevel) bool {
if isUpdate {
return true
}
isFieldUnique, _ := node.IsIDUnique()
return isFieldUnique
})
_ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
_, err := node.GetNetwork()
return err == nil
})
_ = v.RegisterValidation("in_charset", func(fl validator.FieldLevel) bool {
isgood := node.NameInNodeCharSet()
return isgood
})
_ = v.RegisterValidation("checkyesorno", func(fl validator.FieldLevel) bool {
return CheckYesOrNo(fl)
})
err := v.Struct(node)
return err
}
func (node *Node) IsIDUnique() (bool, error) {
_, err := database.FetchRecord(database.NODES_TABLE_NAME, node.ID)
return database.IsEmptyRecord(err), err
}
func (node *Node) NameInNodeCharSet() bool {
charset := "abcdefghijklmnopqrstuvwxyz1234567890-"
@@ -528,29 +379,6 @@ func (node *Node) NameInNodeCharSet() bool {
return true
}
func GetAllNodes() ([]Node, error) {
var nodes []Node
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
if database.IsEmptyRecord(err) {
return []Node{}, nil
}
return []Node{}, err
}
for _, value := range collection {
var node Node
if err := json.Unmarshal([]byte(value), &node); err != nil {
return []Node{}, err
}
// add node to our array
nodes = append(nodes, node)
}
return nodes, nil
}
func (node *Node) GetID() (string, error) {
if node.MacAddress == "" || node.Network == "" {
return "", errors.New("unable to get record key")

4
netclient/functions/checkin.go
View File

@@ -230,10 +230,6 @@ func Pull(network string, manual bool) (*models.Node, error) {
if err != nil {
return &resNode, err
}
} else { // handle server side update
if err = resNode.Update(&resNode); err != nil {
return &resNode, err
}
}
} else {
if err = wireguard.SetWGConfig(network, true); err != nil {

38
relay/relay.go
View File

@@ -1,38 +0,0 @@
package relay
import (
"encoding/json"
"errors"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/models"
)
// GetNodeRelay - gets the relay node of a given network
func GetNodeRelay(network string, relayedNodeAddr string) (models.Node, error) {
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
var relay models.Node
if err != nil {
if database.IsEmptyRecord(err) {
return relay, nil
}
functions.PrintUserLog("", err.Error(), 2)
return relay, err
}
for _, value := range collection {
err := json.Unmarshal([]byte(value), &relay)
if err != nil {
functions.PrintUserLog("", err.Error(), 2)
continue
}
if relay.IsRelay == "yes" {
for _, addr := range relay.RelayAddrs {
if addr == relayedNodeAddr {
return relay, nil
}
}
}
}
return relay, errors.New("could not find relay for node " + relayedNodeAddr)
}

2
serverctl/serverctl.go
View File

@@ -90,7 +90,7 @@ func InitServerNetclient() error {
// HandleContainedClient - function for checkins on server
func HandleContainedClient() error {
servernets, err := models.GetNetworks()
servernets, err := logic.GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
return err
}

2
models/validation.go → validation/validation.go
View File

@@ -1,4 +1,4 @@
package models
package validation
import (
"regexp"