mirror of
https://github.com/gravitl/netmaker.git
synced 2025-09-09 06:35:23 +08:00
Merge branch 'develop' of https://github.com/gravitl/netmaker into GRA-1194/extclient_egress
This commit is contained in:
Abhishek Kondur
commit
a117131bfd
12 changed files with 514 additions and 203 deletions
1
.github/workflows/test.yml
vendored
1
.github/workflows/test.yml
vendored
|
|
@ -49,6 +49,7 @@ jobs:
|
|||
go-version: 1.19
|
||||
- name: run tests
|
||||
run: |
|
||||
go vet ./...
|
||||
go test -p 1 ./... -v
|
||||
env:
|
||||
DATABASE: sqlite
|
||||
|
|
|
|||
|
|
@ -176,9 +176,14 @@ func createDNS(w http.ResponseWriter, r *http.Request) {
|
|||
}
|
||||
logger.Log(1, "new DNS record added:", entry.Name)
|
||||
if servercfg.IsMessageQueueBackend() {
|
||||
if err = mq.PublishPeerUpdate(); err != nil {
|
||||
logger.Log(0, "failed to publish peer update after ACL update on", entry.Network)
|
||||
}
|
||||
go func() {
|
||||
if err = mq.PublishPeerUpdate(); err != nil {
|
||||
logger.Log(0, "failed to publish peer update after ACL update on", entry.Network)
|
||||
}
|
||||
if err := mq.PublishCustomDNS(&entry); err != nil {
|
||||
logger.Log(0, "error publishing custom dns", err.Error())
|
||||
}
|
||||
}()
|
||||
}
|
||||
logger.Log(2, r.Header.Get("user"),
|
||||
fmt.Sprintf("DNS entry is set: %+v", entry))
|
||||
|
|
@ -221,6 +226,16 @@ func deleteDNS(w http.ResponseWriter, r *http.Request) {
|
|||
return
|
||||
}
|
||||
json.NewEncoder(w).Encode(entrytext + " deleted.")
|
||||
go func() {
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSDeleteByName,
|
||||
Name: entrytext,
|
||||
}
|
||||
if err := mq.PublishDNSUpdate(params["network"], dns); err != nil {
|
||||
logger.Log(0, "failed to publish dns update", err.Error())
|
||||
}
|
||||
}()
|
||||
|
||||
}
|
||||
|
||||
// GetDNSEntry - gets a DNS entry
|
||||
|
|
|
|||
|
|
@ -6,10 +6,11 @@ import (
|
|||
"testing"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/gravitl/netmaker/logic"
|
||||
"github.com/gravitl/netmaker/models"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
|
||||
|
||||
"github.com/gravitl/netmaker/logic"
|
||||
"github.com/gravitl/netmaker/models"
|
||||
)
|
||||
|
||||
var dnsHost models.Host
|
||||
|
|
@ -26,7 +27,7 @@ func TestGetAllDNS(t *testing.T) {
|
|||
})
|
||||
t.Run("OneEntry", func(t *testing.T) {
|
||||
entry := models.DNSEntry{
|
||||
"10.0.0.3", "", "newhost", "skynet",
|
||||
Address: "10.0.0.3", Name: "newhost", Network: "skynet",
|
||||
}
|
||||
_, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
|
|
@ -35,7 +36,7 @@ func TestGetAllDNS(t *testing.T) {
|
|||
assert.Equal(t, 1, len(entries))
|
||||
})
|
||||
t.Run("MultipleEntry", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.7", "", "anotherhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.7", Name: "anotherhost", Network: "skynet"}
|
||||
_, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
entries, err := logic.GetAllDNS()
|
||||
|
|
@ -111,7 +112,7 @@ func TestGetCustomDNS(t *testing.T) {
|
|||
assert.Equal(t, 0, len(dns))
|
||||
})
|
||||
t.Run("EntryExist", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.3", "", "custom1", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.3", Name: "custom1", Network: "skynet"}
|
||||
_, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
dns, err := logic.GetCustomDNS("skynet")
|
||||
|
|
@ -119,7 +120,7 @@ func TestGetCustomDNS(t *testing.T) {
|
|||
assert.Equal(t, 1, len(dns))
|
||||
})
|
||||
t.Run("MultipleEntries", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.4", "", "host4", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.4", Name: "host4", Network: "skynet"}
|
||||
_, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
dns, err := logic.GetCustomDNS("skynet")
|
||||
|
|
@ -138,7 +139,7 @@ func TestGetDNSEntryNum(t *testing.T) {
|
|||
assert.Equal(t, 0, num)
|
||||
})
|
||||
t.Run("NodeExists", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
|
||||
_, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
num, err := logic.GetDNSEntryNum("newhost", "skynet")
|
||||
|
|
@ -156,7 +157,7 @@ func TestGetDNS(t *testing.T) {
|
|||
assert.Nil(t, dns)
|
||||
})
|
||||
t.Run("CustomDNSExists", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
|
||||
_, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
dns, err := logic.GetDNS("skynet")
|
||||
|
|
@ -176,7 +177,7 @@ func TestGetDNS(t *testing.T) {
|
|||
assert.Equal(t, 1, len(dns))
|
||||
})
|
||||
t.Run("NodeAndCustomDNS", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
|
||||
_, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
dns, err := logic.GetDNS("skynet")
|
||||
|
|
@ -193,7 +194,7 @@ func TestCreateDNS(t *testing.T) {
|
|||
deleteAllDNS(t)
|
||||
deleteAllNetworks()
|
||||
createNet()
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
|
||||
dns, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, "newhost", dns.Name)
|
||||
|
|
@ -231,7 +232,7 @@ func TestSetDNS(t *testing.T) {
|
|||
assert.Contains(t, string(content), "linuxhost.skynet")
|
||||
})
|
||||
t.Run("EntryExists", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.3", "", "newhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.3", Name: "newhost", Network: "skynet"}
|
||||
_, err := logic.CreateDNS(entry)
|
||||
assert.Nil(t, err)
|
||||
err = logic.SetDNS()
|
||||
|
|
@ -251,7 +252,7 @@ func TestGetDNSEntry(t *testing.T) {
|
|||
deleteAllNetworks()
|
||||
createNet()
|
||||
createTestNode()
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
|
||||
_, _ = logic.CreateDNS(entry)
|
||||
t.Run("wrong net", func(t *testing.T) {
|
||||
entry, err := GetDNSEntry("newhost", "w286 Toronto Street South, Uxbridge, ONirecat")
|
||||
|
|
@ -279,7 +280,7 @@ func TestDeleteDNS(t *testing.T) {
|
|||
deleteAllDNS(t)
|
||||
deleteAllNetworks()
|
||||
createNet()
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
|
||||
_, _ = logic.CreateDNS(entry)
|
||||
t.Run("EntryExists", func(t *testing.T) {
|
||||
err := logic.DeleteDNS("newhost", "skynet")
|
||||
|
|
@ -300,16 +301,16 @@ func TestValidateDNSUpdate(t *testing.T) {
|
|||
deleteAllDNS(t)
|
||||
deleteAllNetworks()
|
||||
createNet()
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "myhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "skynet"}
|
||||
t.Run("BadNetwork", func(t *testing.T) {
|
||||
change := models.DNSEntry{"10.0.0.2", "", "myhost", "badnet"}
|
||||
change := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "badnet"}
|
||||
err := logic.ValidateDNSUpdate(change, entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Network' failed on the 'network_exists' tag")
|
||||
})
|
||||
t.Run("EmptyNetwork", func(t *testing.T) {
|
||||
//this can't actually happen as change.Network is populated if is blank
|
||||
change := models.DNSEntry{"10.0.0.2", "", "myhost", ""}
|
||||
// this can't actually happen as change.Network is populated if is blank
|
||||
change := models.DNSEntry{Address: "10.0.0.2", Name: "myhost"}
|
||||
err := logic.ValidateDNSUpdate(change, entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Network' failed on the 'network_exists' tag")
|
||||
|
|
@ -322,14 +323,14 @@ func TestValidateDNSUpdate(t *testing.T) {
|
|||
// assert.Contains(t, err.Error(), "Field validation for 'Address' failed on the 'required' tag")
|
||||
// })
|
||||
t.Run("BadAddress", func(t *testing.T) {
|
||||
change := models.DNSEntry{"10.0.256.1", "", "myhost", "skynet"}
|
||||
change := models.DNSEntry{Address: "10.0.256.1", Name: "myhost", Network: "skynet"}
|
||||
err := logic.ValidateDNSUpdate(change, entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Address' failed on the 'ip' tag")
|
||||
})
|
||||
t.Run("EmptyName", func(t *testing.T) {
|
||||
//this can't actually happen as change.Name is populated if is blank
|
||||
change := models.DNSEntry{"10.0.0.2", "", "", "skynet"}
|
||||
// this can't actually happen as change.Name is populated if is blank
|
||||
change := models.DNSEntry{Address: "10.0.0.2", Network: "skynet"}
|
||||
err := logic.ValidateDNSUpdate(change, entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'required' tag")
|
||||
|
|
@ -339,19 +340,19 @@ func TestValidateDNSUpdate(t *testing.T) {
|
|||
for i := 1; i < 194; i++ {
|
||||
name = name + "a"
|
||||
}
|
||||
change := models.DNSEntry{"10.0.0.2", "", name, "skynet"}
|
||||
change := models.DNSEntry{Address: "10.0.0.2", Name: name, Network: "skynet"}
|
||||
err := logic.ValidateDNSUpdate(change, entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'max' tag")
|
||||
})
|
||||
t.Run("NameUnique", func(t *testing.T) {
|
||||
change := models.DNSEntry{"10.0.0.2", "", "myhost", "wirecat"}
|
||||
change := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "wirecat"}
|
||||
_, _ = logic.CreateDNS(entry)
|
||||
_, _ = logic.CreateDNS(change)
|
||||
err := logic.ValidateDNSUpdate(change, entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'name_unique' tag")
|
||||
//cleanup
|
||||
// cleanup
|
||||
err = logic.DeleteDNS("myhost", "wirecat")
|
||||
assert.Nil(t, err)
|
||||
})
|
||||
|
|
@ -360,7 +361,7 @@ func TestValidateDNSUpdate(t *testing.T) {
|
|||
func TestValidateDNSCreate(t *testing.T) {
|
||||
_ = logic.DeleteDNS("mynode", "skynet")
|
||||
t.Run("NoNetwork", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "myhost", "badnet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "badnet"}
|
||||
err := logic.ValidateDNSCreate(entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Network' failed on the 'network_exists' tag")
|
||||
|
|
@ -372,13 +373,13 @@ func TestValidateDNSCreate(t *testing.T) {
|
|||
// assert.Contains(t, err.Error(), "Field validation for 'Address' failed on the 'required' tag")
|
||||
// })
|
||||
t.Run("BadAddress", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.256.1", "", "myhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.256.1", Name: "myhost", Network: "skynet"}
|
||||
err := logic.ValidateDNSCreate(entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Address' failed on the 'ip' tag")
|
||||
})
|
||||
t.Run("EmptyName", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Network: "skynet"}
|
||||
err := logic.ValidateDNSCreate(entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'required' tag")
|
||||
|
|
@ -388,13 +389,13 @@ func TestValidateDNSCreate(t *testing.T) {
|
|||
for i := 1; i < 194; i++ {
|
||||
name = name + "a"
|
||||
}
|
||||
entry := models.DNSEntry{"10.0.0.2", "", name, "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: name, Network: "skynet"}
|
||||
err := logic.ValidateDNSCreate(entry)
|
||||
assert.NotNil(t, err)
|
||||
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'max' tag")
|
||||
})
|
||||
t.Run("NameUnique", func(t *testing.T) {
|
||||
entry := models.DNSEntry{"10.0.0.2", "", "myhost", "skynet"}
|
||||
entry := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "skynet"}
|
||||
_, _ = logic.CreateDNS(entry)
|
||||
err := logic.ValidateDNSCreate(entry)
|
||||
assert.NotNil(t, err)
|
||||
|
|
|
|||
|
|
@ -388,10 +388,15 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
|
|||
|
||||
logger.Log(0, r.Header.Get("user"), "created new ext client on network", networkName)
|
||||
w.WriteHeader(http.StatusOK)
|
||||
err = mq.PublishExtPeerUpdate(&node)
|
||||
if err != nil {
|
||||
logger.Log(1, "error setting ext peers on "+nodeid+": "+err.Error())
|
||||
}
|
||||
go func() {
|
||||
err = mq.PublishExtPeerUpdate(&node)
|
||||
if err != nil {
|
||||
logger.Log(1, "error setting ext peers on "+nodeid+": "+err.Error())
|
||||
}
|
||||
if err := mq.PublishExtCLientDNS(&extclient); err != nil {
|
||||
logger.Log(1, "error publishing extclient dns", err.Error())
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// swagger:route PUT /api/extclients/{network}/{clientid} ext_client updateExtClient
|
||||
|
|
@ -459,7 +464,6 @@ func updateExtClient(w http.ResponseWriter, r *http.Request) {
|
|||
return
|
||||
}
|
||||
}
|
||||
|
||||
if changedID && oldExtClient.OwnerID != "" {
|
||||
if err := pro.DissociateNetworkUserClient(oldExtClient.OwnerID, networkName, oldExtClient.ClientID); err != nil {
|
||||
logger.Log(0, "failed to dissociate client", oldExtClient.ClientID, "from user", oldExtClient.OwnerID)
|
||||
|
|
@ -471,7 +475,8 @@ func updateExtClient(w http.ResponseWriter, r *http.Request) {
|
|||
// == END PRO ==
|
||||
|
||||
var changedEnabled = newExtClient.Enabled != oldExtClient.Enabled // indicates there was a change in enablement
|
||||
|
||||
// extra var need as logic.Update changes oldExtClient
|
||||
currentClient := oldExtClient
|
||||
newclient, err := logic.UpdateExtClient(newExtClient.ClientID, params["network"], newExtClient.Enabled, &oldExtClient)
|
||||
if err != nil {
|
||||
logger.Log(0, r.Header.Get("user"),
|
||||
|
|
@ -490,6 +495,13 @@ func updateExtClient(w http.ResponseWriter, r *http.Request) {
|
|||
}
|
||||
w.WriteHeader(http.StatusOK)
|
||||
json.NewEncoder(w).Encode(newclient)
|
||||
if changedID {
|
||||
go func() {
|
||||
if err := mq.PublishExtClientDNSUpdate(currentClient, newExtClient, networkName); err != nil {
|
||||
logger.Log(1, "error pubishing dns update for extcient update", err.Error())
|
||||
}
|
||||
}()
|
||||
}
|
||||
}
|
||||
|
||||
// swagger:route DELETE /api/extclients/{network}/{clientid} ext_client deleteExtClient
|
||||
|
|
@ -554,10 +566,15 @@ func deleteExtClient(w http.ResponseWriter, r *http.Request) {
|
|||
return
|
||||
}
|
||||
|
||||
err = mq.PublishExtPeerUpdate(&ingressnode)
|
||||
if err != nil {
|
||||
logger.Log(1, "error setting ext peers on "+ingressnode.ID.String()+": "+err.Error())
|
||||
}
|
||||
go func() {
|
||||
err = mq.PublishExtPeerUpdate(&ingressnode)
|
||||
if err != nil {
|
||||
logger.Log(1, "error setting ext peers on "+ingressnode.ID.String()+": "+err.Error())
|
||||
}
|
||||
if err := mq.PublishDeleteExtClientDNS(&extclient); err != nil {
|
||||
logger.Log(1, "error publishing dns update for extclient deletion", err.Error())
|
||||
}
|
||||
}()
|
||||
|
||||
logger.Log(0, r.Header.Get("user"),
|
||||
"Deleted extclient client", params["clientid"], "from network", params["network"])
|
||||
|
|
|
|||
|
|
@ -108,6 +108,19 @@ func updateHost(w http.ResponseWriter, r *http.Request) {
|
|||
if err := mq.PublishPeerUpdate(); err != nil {
|
||||
logger.Log(0, "fail to publish peer update: ", err.Error())
|
||||
}
|
||||
if newHost.Name != currHost.Name {
|
||||
networks := logic.GetHostNetworks(currHost.ID.String())
|
||||
if err := mq.PublishHostDNSUpdate(currHost, newHost, networks); err != nil {
|
||||
var dnsError *models.DNSError
|
||||
if errors.Is(err, dnsError) {
|
||||
for _, message := range err.(models.DNSError).ErrorStrings {
|
||||
logger.Log(0, message)
|
||||
}
|
||||
} else {
|
||||
logger.Log(0, err.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
apiHostData := newHost.ConvertNMHostToAPI()
|
||||
|
|
@ -282,6 +295,9 @@ func deleteHostFromNetwork(w http.ResponseWriter, r *http.Request) {
|
|||
if err := mq.PublishPeerUpdate(); err != nil {
|
||||
logger.Log(1, "error publishing peer update ", err.Error())
|
||||
}
|
||||
if err := mq.PublishDNSDelete(node, currHost); err != nil {
|
||||
logger.Log(1, "error publishing dns update", err.Error())
|
||||
}
|
||||
}()
|
||||
logger.Log(2, r.Header.Get("user"), fmt.Sprintf("removed host %s from network %s", currHost.Name, network))
|
||||
w.WriteHeader(http.StatusOK)
|
||||
|
|
|
|||
|
|
@ -657,6 +657,30 @@ func createNode(w http.ResponseWriter, r *http.Request) {
|
|||
}
|
||||
}()
|
||||
//runForceServerUpdate(&data.Node, true)
|
||||
go func() {
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSInsert,
|
||||
Name: data.Host.Name + "." + data.Node.Network,
|
||||
}
|
||||
if data.Node.Address.IP != nil {
|
||||
dns.Address = data.Node.Address.IP.String()
|
||||
//publish new node dns entry to all nodes on network
|
||||
if err := mq.PublishDNSUpdate(data.Node.Network, dns); err != nil {
|
||||
logger.Log(1, "failed to publish dns update on node creation", err.Error())
|
||||
}
|
||||
}
|
||||
if data.Node.Address6.IP != nil {
|
||||
dns.Address = data.Node.Address6.IP.String()
|
||||
//publish new node dns entry to all nodes on network
|
||||
if err := mq.PublishDNSUpdate(data.Node.Network, dns); err != nil {
|
||||
logger.Log(1, "failed to publish dns update on node creation", err.Error())
|
||||
}
|
||||
}
|
||||
//publish add dns records for network to new node
|
||||
if err := mq.PublishAllDNS(&data.Node); err != nil {
|
||||
logger.Log(1, "failed to publish dns update on node creation", err.Error())
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// == EGRESS ==
|
||||
|
|
@ -929,6 +953,11 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
|
|||
json.NewEncoder(w).Encode(apiNode)
|
||||
|
||||
runUpdates(newNode, ifaceDelta)
|
||||
go func() {
|
||||
if err := mq.PublishReplaceDNS(¤tNode, newNode, host); err != nil {
|
||||
logger.Log(1, "failed to publish dns update", err.Error())
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// swagger:route DELETE /api/nodes/{network}/{nodeid} nodes deleteNode
|
||||
|
|
@ -976,6 +1005,13 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
|
|||
if err := mq.PublishPeerUpdate(); err != nil {
|
||||
logger.Log(1, "error publishing peer update ", err.Error())
|
||||
}
|
||||
host, err := logic.GetHost(node.HostID.String())
|
||||
if err != nil {
|
||||
logger.Log(1, "failed to retrieve host for node", node.ID.String(), err.Error())
|
||||
}
|
||||
if err := mq.PublishDNSDelete(&node, host); err != nil {
|
||||
logger.Log(1, "error publishing dns update", err.Error())
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,20 +3,24 @@ package controller
|
|||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
"github.com/gravitl/netmaker/logic"
|
||||
"github.com/gravitl/netmaker/models"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func deleteAllUsers() {
|
||||
func deleteAllUsers(t *testing.T) {
|
||||
t.Helper()
|
||||
users, _ := logic.GetUsers()
|
||||
for _, user := range users {
|
||||
logic.DeleteUser(user.UserName)
|
||||
if _, err := logic.DeleteUser(user.UserName); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasAdmin(t *testing.T) {
|
||||
//delete all current users
|
||||
// delete all current users
|
||||
users, _ := logic.GetUsers()
|
||||
for _, user := range users {
|
||||
success, err := logic.DeleteUser(user.UserName)
|
||||
|
|
@ -29,7 +33,7 @@ func TestHasAdmin(t *testing.T) {
|
|||
assert.False(t, found)
|
||||
})
|
||||
t.Run("No admin user", func(t *testing.T) {
|
||||
var user = models.User{"noadmin", "password", nil, false, nil}
|
||||
var user = models.User{UserName: "noadmin", Password: "password"}
|
||||
err := logic.CreateUser(&user)
|
||||
assert.Nil(t, err)
|
||||
found, err := logic.HasAdmin()
|
||||
|
|
@ -37,7 +41,7 @@ func TestHasAdmin(t *testing.T) {
|
|||
assert.False(t, found)
|
||||
})
|
||||
t.Run("admin user", func(t *testing.T) {
|
||||
var user = models.User{"admin", "password", nil, true, nil}
|
||||
var user = models.User{UserName: "admin", Password: "password", IsAdmin: true}
|
||||
err := logic.CreateUser(&user)
|
||||
assert.Nil(t, err)
|
||||
found, err := logic.HasAdmin()
|
||||
|
|
@ -45,7 +49,7 @@ func TestHasAdmin(t *testing.T) {
|
|||
assert.True(t, found)
|
||||
})
|
||||
t.Run("multiple admins", func(t *testing.T) {
|
||||
var user = models.User{"admin1", "password", nil, true, nil}
|
||||
var user = models.User{UserName: "admin1", Password: "password", IsAdmin: true}
|
||||
err := logic.CreateUser(&user)
|
||||
assert.Nil(t, err)
|
||||
found, err := logic.HasAdmin()
|
||||
|
|
@ -55,8 +59,8 @@ func TestHasAdmin(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestCreateUser(t *testing.T) {
|
||||
deleteAllUsers()
|
||||
user := models.User{"admin", "password", nil, true, nil}
|
||||
deleteAllUsers(t)
|
||||
user := models.User{UserName: "admin", Password: "password", IsAdmin: true}
|
||||
t.Run("NoUser", func(t *testing.T) {
|
||||
err := logic.CreateUser(&user)
|
||||
assert.Nil(t, err)
|
||||
|
|
@ -69,7 +73,7 @@ func TestCreateUser(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestCreateAdmin(t *testing.T) {
|
||||
deleteAllUsers()
|
||||
deleteAllUsers(t)
|
||||
var user models.User
|
||||
t.Run("NoAdmin", func(t *testing.T) {
|
||||
user.UserName = "admin"
|
||||
|
|
@ -86,15 +90,17 @@ func TestCreateAdmin(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDeleteUser(t *testing.T) {
|
||||
deleteAllUsers()
|
||||
deleteAllUsers(t)
|
||||
t.Run("NonExistent User", func(t *testing.T) {
|
||||
deleted, err := logic.DeleteUser("admin")
|
||||
assert.EqualError(t, err, "user does not exist")
|
||||
assert.False(t, deleted)
|
||||
})
|
||||
t.Run("Existing User", func(t *testing.T) {
|
||||
user := models.User{"admin", "password", nil, true, nil}
|
||||
logic.CreateUser(&user)
|
||||
user := models.User{UserName: "admin", Password: "password", IsAdmin: true}
|
||||
if err := logic.CreateUser(&user); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
deleted, err := logic.DeleteUser("admin")
|
||||
assert.Nil(t, err)
|
||||
assert.True(t, deleted)
|
||||
|
|
@ -120,21 +126,21 @@ func TestValidateUser(t *testing.T) {
|
|||
user.UserName = "*invalid"
|
||||
err := logic.ValidateUser(&user)
|
||||
assert.Error(t, err)
|
||||
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
|
||||
// assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
|
||||
})
|
||||
t.Run("Short UserName", func(t *testing.T) {
|
||||
t.Skip()
|
||||
user.UserName = "1"
|
||||
err := logic.ValidateUser(&user)
|
||||
assert.NotNil(t, err)
|
||||
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
|
||||
// assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
|
||||
})
|
||||
t.Run("Empty UserName", func(t *testing.T) {
|
||||
t.Skip()
|
||||
user.UserName = ""
|
||||
err := logic.ValidateUser(&user)
|
||||
assert.EqualError(t, err, "some string")
|
||||
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
|
||||
// assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
|
||||
})
|
||||
t.Run("EmptyPassword", func(t *testing.T) {
|
||||
user.Password = ""
|
||||
|
|
@ -149,15 +155,19 @@ func TestValidateUser(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestGetUser(t *testing.T) {
|
||||
deleteAllUsers()
|
||||
deleteAllUsers(t)
|
||||
|
||||
user := models.User{UserName: "admin", Password: "password", Networks: nil, IsAdmin: true, Groups: nil}
|
||||
|
||||
t.Run("NonExistantUser", func(t *testing.T) {
|
||||
admin, err := logic.GetUser("admin")
|
||||
assert.EqualError(t, err, "could not find any records")
|
||||
assert.Equal(t, "", admin.UserName)
|
||||
})
|
||||
t.Run("UserExisits", func(t *testing.T) {
|
||||
user := models.User{"admin", "password", nil, true, nil}
|
||||
logic.CreateUser(&user)
|
||||
if err := logic.CreateUser(&user); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
admin, err := logic.GetUser("admin")
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, user.UserName, admin.UserName)
|
||||
|
|
@ -165,29 +175,36 @@ func TestGetUser(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestGetUsers(t *testing.T) {
|
||||
deleteAllUsers()
|
||||
deleteAllUsers(t)
|
||||
|
||||
adminUser := models.User{UserName: "admin", Password: "password", IsAdmin: true}
|
||||
user := models.User{UserName: "admin", Password: "password", IsAdmin: false}
|
||||
|
||||
t.Run("NonExistantUser", func(t *testing.T) {
|
||||
admin, err := logic.GetUsers()
|
||||
assert.EqualError(t, err, "could not find any records")
|
||||
assert.Equal(t, []models.ReturnUser(nil), admin)
|
||||
})
|
||||
t.Run("UserExisits", func(t *testing.T) {
|
||||
user := models.User{"admin", "password", nil, true, nil}
|
||||
logic.CreateUser(&user)
|
||||
if err := logic.CreateUser(&adminUser); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
admins, err := logic.GetUsers()
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, user.UserName, admins[0].UserName)
|
||||
assert.Equal(t, adminUser.UserName, admins[0].UserName)
|
||||
})
|
||||
t.Run("MulipleUsers", func(t *testing.T) {
|
||||
user := models.User{"user", "password", nil, true, nil}
|
||||
logic.CreateUser(&user)
|
||||
if err := logic.CreateUser(&user); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
admins, err := logic.GetUsers()
|
||||
assert.Nil(t, err)
|
||||
for _, u := range admins {
|
||||
if u.UserName == "admin" {
|
||||
assert.Equal(t, "admin", u.UserName)
|
||||
assert.Equal(t, true, u.IsAdmin)
|
||||
} else {
|
||||
assert.Equal(t, user.UserName, u.UserName)
|
||||
assert.Equal(t, user.IsAdmin, u.IsAdmin)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
|
@ -195,9 +212,9 @@ func TestGetUsers(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestUpdateUser(t *testing.T) {
|
||||
deleteAllUsers()
|
||||
user := models.User{"admin", "password", nil, true, nil}
|
||||
newuser := models.User{"hello", "world", []string{"wirecat, netmaker"}, true, []string{}}
|
||||
deleteAllUsers(t)
|
||||
user := models.User{UserName: "admin", Password: "password", IsAdmin: true}
|
||||
newuser := models.User{UserName: "hello", Password: "world", Networks: []string{"wirecat, netmaker"}, IsAdmin: true, Groups: []string{}}
|
||||
t.Run("NonExistantUser", func(t *testing.T) {
|
||||
admin, err := logic.UpdateUser(&newuser, &user)
|
||||
assert.EqualError(t, err, "could not find any records")
|
||||
|
|
@ -205,7 +222,9 @@ func TestUpdateUser(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("UserExists", func(t *testing.T) {
|
||||
logic.CreateUser(&user)
|
||||
if err := logic.CreateUser(&user); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
admin, err := logic.UpdateUser(&newuser, &user)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, newuser.UserName, admin.UserName)
|
||||
|
|
@ -237,7 +256,8 @@ func TestUpdateUser(t *testing.T) {
|
|||
// }
|
||||
|
||||
func TestVerifyAuthRequest(t *testing.T) {
|
||||
deleteAllUsers()
|
||||
deleteAllUsers(t)
|
||||
user := models.User{UserName: "admin", Password: "password", Networks: nil, IsAdmin: true, Groups: nil}
|
||||
var authRequest models.UserAuthParams
|
||||
t.Run("EmptyUserName", func(t *testing.T) {
|
||||
authRequest.UserName = ""
|
||||
|
|
@ -261,23 +281,26 @@ func TestVerifyAuthRequest(t *testing.T) {
|
|||
assert.EqualError(t, err, "error retrieving user from db: could not find any records")
|
||||
})
|
||||
t.Run("Non-Admin", func(t *testing.T) {
|
||||
user := models.User{"nonadmin", "somepass", nil, false, []string{}}
|
||||
logic.CreateUser(&user)
|
||||
authRequest := models.UserAuthParams{"nonadmin", "somepass"}
|
||||
if err := logic.CreateUser(&user); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
authRequest := models.UserAuthParams{UserName: "nonadmin", Password: "somepass"}
|
||||
jwt, err := logic.VerifyAuthRequest(authRequest)
|
||||
assert.NotNil(t, jwt)
|
||||
assert.Nil(t, err)
|
||||
})
|
||||
t.Run("WrongPassword", func(t *testing.T) {
|
||||
user := models.User{"admin", "password", nil, false, []string{}}
|
||||
logic.CreateUser(&user)
|
||||
authRequest := models.UserAuthParams{"admin", "badpass"}
|
||||
user := models.User{UserName: "admin", Password: "password", Groups: []string{}}
|
||||
if err := logic.CreateUser(&user); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
authRequest := models.UserAuthParams{UserName: "admin", Password: "badpass"}
|
||||
jwt, err := logic.VerifyAuthRequest(authRequest)
|
||||
assert.Equal(t, "", jwt)
|
||||
assert.EqualError(t, err, "incorrect credentials")
|
||||
})
|
||||
t.Run("Success", func(t *testing.T) {
|
||||
authRequest := models.UserAuthParams{"admin", "password"}
|
||||
authRequest := models.UserAuthParams{UserName: "admin", Password: "password"}
|
||||
jwt, err := logic.VerifyAuthRequest(authRequest)
|
||||
assert.Nil(t, err)
|
||||
assert.NotNil(t, jwt)
|
||||
|
|
|
|||
|
|
@ -301,7 +301,6 @@ func GetPeerUpdateForHost(host *models.Host) (models.HostPeerUpdate, error) {
|
|||
hostPeerUpdate := models.HostPeerUpdate{
|
||||
Host: *host,
|
||||
Server: servercfg.GetServer(),
|
||||
Network: make(map[string]models.NetworkInfo),
|
||||
PeerIDs: make(models.HostPeerMap),
|
||||
ServerVersion: servercfg.GetVersion(),
|
||||
ServerAddrs: []models.ServerAddr{},
|
||||
|
|
@ -320,10 +319,6 @@ func GetPeerUpdateForHost(host *models.Host) (models.HostPeerUpdate, error) {
|
|||
if !node.Connected || node.Action == models.NODE_DELETE || node.PendingDelete {
|
||||
continue
|
||||
}
|
||||
|
||||
hostPeerUpdate.Network[node.Network] = models.NetworkInfo{
|
||||
DNS: getPeerDNS(node.Network),
|
||||
}
|
||||
currentPeers, err := GetNetworkNodes(node.Network)
|
||||
if err != nil {
|
||||
log.Println("no network nodes")
|
||||
|
|
@ -526,7 +521,6 @@ func GetPeerUpdate(node *models.Node, host *models.Host) (models.PeerUpdate, err
|
|||
peerUpdate := models.PeerUpdate{
|
||||
Network: node.Network,
|
||||
ServerVersion: ncutils.Version,
|
||||
DNS: getPeerDNS(node.Network),
|
||||
PeerIDs: make(models.PeerMap),
|
||||
}
|
||||
currentPeers, err := GetNetworkNodes(node.Network)
|
||||
|
|
@ -795,7 +789,6 @@ func GetPeerUpdateLegacy(node *models.Node) (models.PeerUpdate, error) {
|
|||
})
|
||||
peerUpdate.Peers = peers
|
||||
peerUpdate.ServerAddrs = serverNodeAddresses
|
||||
peerUpdate.DNS = getPeerDNS(node.Network)
|
||||
peerUpdate.PeerIDs = peerMap
|
||||
return peerUpdate, nil
|
||||
}
|
||||
|
|
@ -966,28 +959,6 @@ func GetAllowedIPs(node, peer *models.Node, metrics *models.Metrics) []net.IPNet
|
|||
return allowedips
|
||||
}
|
||||
|
||||
func getPeerDNS(network string) string {
|
||||
var dns string
|
||||
if nodes, err := GetNetworkNodes(network); err == nil {
|
||||
for i, node := range nodes {
|
||||
host, err := GetHost(node.HostID.String())
|
||||
if err != nil {
|
||||
logger.Log(0, "error retrieving host for node", node.ID.String(), err.Error())
|
||||
continue
|
||||
}
|
||||
dns = dns + fmt.Sprintf("%s %s.%s\n", nodes[i].Address, host.Name, nodes[i].Network)
|
||||
}
|
||||
}
|
||||
|
||||
if customDNSEntries, err := GetCustomDNS(network); err == nil {
|
||||
for _, entry := range customDNSEntries {
|
||||
// TODO - filter entries based on ACLs / given peers vs nodes in network
|
||||
dns = dns + fmt.Sprintf("%s %s.%s\n", entry.Address, entry.Name, entry.Network)
|
||||
}
|
||||
}
|
||||
return dns
|
||||
}
|
||||
|
||||
// GetPeerUpdateForRelayedNode - calculates peer update for a relayed node by getting the relay
|
||||
// copying the relay node's allowed ips and making appropriate substitutions
|
||||
func GetPeerUpdateForRelayedNode(node *models.Node, udppeers map[string]string) (models.PeerUpdate, error) {
|
||||
|
|
@ -1126,7 +1097,6 @@ func GetPeerUpdateForRelayedNode(node *models.Node, udppeers map[string]string)
|
|||
})
|
||||
peerUpdate.Peers = peers
|
||||
peerUpdate.ServerAddrs = serverNodeAddresses
|
||||
peerUpdate.DNS = getPeerDNS(node.Network)
|
||||
return peerUpdate, nil
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,45 @@
|
|||
// TODO: Either add a returnNetwork and returnKey, or delete this
|
||||
package models
|
||||
|
||||
// DNSUpdateAction identifies the action to be performed with the dns update data
|
||||
type DNSUpdateAction int
|
||||
|
||||
const (
|
||||
// DNSDeleteByIP delete the dns entry
|
||||
DNSDeleteByIP = iota
|
||||
// DNSDeleteByName delete the dns entry
|
||||
DNSDeleteByName
|
||||
// DNSReplaceName replace the dns entry
|
||||
DNSReplaceName
|
||||
// DNSReplaceIP resplace the dns entry
|
||||
DNSReplaceIP
|
||||
// DNSInsert insert a new dns entry
|
||||
DNSInsert
|
||||
)
|
||||
|
||||
func (action DNSUpdateAction) String() string {
|
||||
return [...]string{"DNSDeleteByIP", "DNSDeletByName", "DNSReplaceName", "DNSReplaceIP", "DNSInsert"}[action]
|
||||
}
|
||||
|
||||
// DNSError.Error implementation of error interface
|
||||
func (e DNSError) Error() string {
|
||||
return "error publishing dns update"
|
||||
}
|
||||
|
||||
// DNSError error struct capable of holding multiple error messages
|
||||
type DNSError struct {
|
||||
ErrorStrings []string
|
||||
}
|
||||
|
||||
// DNSUpdate data for updating entries in /etc/hosts
|
||||
type DNSUpdate struct {
|
||||
Action DNSUpdateAction
|
||||
Name string
|
||||
NewName string
|
||||
Address string
|
||||
NewAddress string
|
||||
}
|
||||
|
||||
// DNSEntry - a DNS entry represented as struct
|
||||
type DNSEntry struct {
|
||||
Address string `json:"address" bson:"address" validate:"ip"`
|
||||
|
|
|
|||
|
|
@ -12,23 +12,21 @@ type PeerUpdate struct {
|
|||
ServerVersion string `json:"serverversion" bson:"serverversion" yaml:"serverversion"`
|
||||
ServerAddrs []ServerAddr `json:"serveraddrs" bson:"serveraddrs" yaml:"serveraddrs"`
|
||||
Peers []wgtypes.PeerConfig `json:"peers" bson:"peers" yaml:"peers"`
|
||||
DNS string `json:"dns" bson:"dns" yaml:"dns"`
|
||||
PeerIDs PeerMap `json:"peerids" bson:"peerids" yaml:"peerids"`
|
||||
ProxyUpdate ProxyManagerPayload `json:"proxy_update" bson:"proxy_update" yaml:"proxy_update"`
|
||||
}
|
||||
|
||||
// HostPeerUpdate - struct for host peer updates
|
||||
type HostPeerUpdate struct {
|
||||
Host Host `json:"host" bson:"host" yaml:"host"`
|
||||
Server string `json:"server" bson:"server" yaml:"server"`
|
||||
ServerVersion string `json:"serverversion" bson:"serverversion" yaml:"serverversion"`
|
||||
ServerAddrs []ServerAddr `json:"serveraddrs" bson:"serveraddrs" yaml:"serveraddrs"`
|
||||
Network map[string]NetworkInfo `json:"network" bson:"network" yaml:"network"`
|
||||
Peers []wgtypes.PeerConfig `json:"peers" bson:"peers" yaml:"peers"`
|
||||
PeerIDs HostPeerMap `json:"peerids" bson:"peerids" yaml:"peerids"`
|
||||
ProxyUpdate ProxyManagerPayload `json:"proxy_update" bson:"proxy_update" yaml:"proxy_update"`
|
||||
EgressInfo map[string]EgressInfo `json:"egress_info" bson:"egress_info" yaml:"egress_info"` // map key is node ID
|
||||
IngressInfo IngressInfo `json:"ingress_info" bson:"ext_peers" yaml:"ext_peers"`
|
||||
Host Host `json:"host" bson:"host" yaml:"host"`
|
||||
Server string `json:"server" bson:"server" yaml:"server"`
|
||||
ServerVersion string `json:"serverversion" bson:"serverversion" yaml:"serverversion"`
|
||||
ServerAddrs []ServerAddr `json:"serveraddrs" bson:"serveraddrs" yaml:"serveraddrs"`
|
||||
Peers []wgtypes.PeerConfig `json:"peers" bson:"peers" yaml:"peers"`
|
||||
PeerIDs HostPeerMap `json:"peerids" bson:"peerids" yaml:"peerids"`
|
||||
ProxyUpdate ProxyManagerPayload `json:"proxy_update" bson:"proxy_update" yaml:"proxy_update"`
|
||||
EgressInfo map[string]EgressInfo `json:"egress_info" bson:"egress_info" yaml:"egress_info"` // map key is node ID
|
||||
IngressInfo IngressInfo `json:"ingress_info" bson:"ext_peers" yaml:"ext_peers"`
|
||||
}
|
||||
|
||||
// IngressInfo - struct for ingress info
|
||||
|
|
@ -63,11 +61,6 @@ type ExtClientInfo struct {
|
|||
Peers map[string]PeerRouteInfo `json:"peers" yaml:"peers"`
|
||||
}
|
||||
|
||||
// NetworkInfo - struct for network info
|
||||
type NetworkInfo struct {
|
||||
DNS string `json:"dns" bson:"dns" yaml:"dns"`
|
||||
}
|
||||
|
||||
// KeyUpdate - key update struct
|
||||
type KeyUpdate struct {
|
||||
Network string `json:"network" bson:"network"`
|
||||
|
|
|
|||
351
mq/publishers.go
351
mq/publishers.go
|
|
@ -56,7 +56,7 @@ func PublishSingleHostUpdate(host *models.Host) error {
|
|||
return publish(host, fmt.Sprintf("peers/host/%s/%s", host.ID.String(), servercfg.GetServer()), data)
|
||||
}
|
||||
|
||||
// PublishPeerUpdate --- publishes a peer update to all the peers of a node
|
||||
// PublishExtPeerUpdate --- publishes a peer update to all the peers of a node
|
||||
func PublishExtPeerUpdate(node *models.Node) error {
|
||||
|
||||
go PublishPeerUpdate()
|
||||
|
|
@ -111,6 +111,279 @@ func HostUpdate(hostUpdate *models.HostUpdate) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
// ServerStartNotify - notifies all non server nodes to pull changes after a restart
|
||||
func ServerStartNotify() error {
|
||||
nodes, err := logic.GetAllNodes()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for i := range nodes {
|
||||
nodes[i].Action = models.NODE_FORCE_UPDATE
|
||||
if err = NodeUpdate(&nodes[i]); err != nil {
|
||||
logger.Log(1, "error when notifying node", nodes[i].ID.String(), "of a server startup")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishDNSUpdate publishes a dns update to all nodes on a network
|
||||
func PublishDNSUpdate(network string, dns models.DNSUpdate) error {
|
||||
nodes, err := logic.GetNetworkNodes(network)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, node := range nodes {
|
||||
host, err := logic.GetHost(node.HostID.String())
|
||||
if err != nil {
|
||||
logger.Log(0, "error retrieving host for dns update", host.ID.String(), err.Error())
|
||||
continue
|
||||
}
|
||||
data, err := json.Marshal(dns)
|
||||
if err != nil {
|
||||
logger.Log(0, "failed to encode dns data for node", node.ID.String(), err.Error())
|
||||
}
|
||||
if err := publish(host, "dns/update/"+host.ID.String()+"/"+servercfg.GetServer(), data); err != nil {
|
||||
logger.Log(0, "error publishing dns update to host", host.ID.String(), err.Error())
|
||||
continue
|
||||
}
|
||||
logger.Log(3, "published dns update to host", host.ID.String())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishAllDNS publishes an array of dns updates (ip / host.network) for each peer to a node joining a network
|
||||
func PublishAllDNS(newnode *models.Node) error {
|
||||
alldns := []models.DNSUpdate{}
|
||||
newnodeHost, err := logic.GetHost(newnode.HostID.String())
|
||||
if err != nil {
|
||||
return fmt.Errorf("error retrieving host for dns update %w", err)
|
||||
}
|
||||
alldns = append(alldns, getNodeDNS(newnode.Network)...)
|
||||
alldns = append(alldns, getExtClientDNS(newnode.Network)...)
|
||||
alldns = append(alldns, getCustomDNS(newnode.Network)...)
|
||||
data, err := json.Marshal(alldns)
|
||||
if err != nil {
|
||||
return fmt.Errorf("error encoding dns data %w", err)
|
||||
}
|
||||
if err := publish(newnodeHost, "dns/all/"+newnodeHost.ID.String()+"/"+servercfg.GetServer(), data); err != nil {
|
||||
return fmt.Errorf("error publishing full dns update to %s, %w", newnodeHost.ID.String(), err)
|
||||
}
|
||||
logger.Log(3, "published full dns update to %s", newnodeHost.ID.String())
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishDNSDelete publish a dns update deleting a node to all hosts on a network
|
||||
func PublishDNSDelete(node *models.Node, host *models.Host) error {
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSDeleteByIP,
|
||||
Name: host.Name + "." + node.Network,
|
||||
}
|
||||
if node.Address.IP != nil {
|
||||
dns.Address = node.Address.IP.String()
|
||||
if err := PublishDNSUpdate(node.Network, dns); err != nil {
|
||||
return fmt.Errorf("dns update node deletion %w", err)
|
||||
}
|
||||
}
|
||||
if node.Address6.IP != nil {
|
||||
dns.Address = node.Address6.IP.String()
|
||||
if err := PublishDNSUpdate(node.Network, dns); err != nil {
|
||||
return fmt.Errorf("dns update node deletion %w", err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishReplaceDNS publish a dns update to replace a dns entry on all hosts in network
|
||||
func PublishReplaceDNS(oldNode, newNode *models.Node, host *models.Host) error {
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSReplaceIP,
|
||||
Name: host.Name + "." + oldNode.Network,
|
||||
}
|
||||
if !oldNode.Address.IP.Equal(newNode.Address.IP) {
|
||||
dns.Address = oldNode.Address.IP.String()
|
||||
dns.NewAddress = newNode.Address.IP.String()
|
||||
if err := PublishDNSUpdate(oldNode.Network, dns); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if !oldNode.Address6.IP.Equal(newNode.Address6.IP) {
|
||||
dns.Address = oldNode.Address6.IP.String()
|
||||
dns.NewAddress = newNode.Address6.IP.String()
|
||||
if err := PublishDNSUpdate(oldNode.Network, dns); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishExtClientDNS publish dns update for new extclient
|
||||
func PublishExtCLientDNS(client *models.ExtClient) error {
|
||||
errMsgs := models.DNSError{}
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSInsert,
|
||||
Name: client.ClientID + "." + client.Network,
|
||||
Address: client.Address,
|
||||
}
|
||||
if client.Address != "" {
|
||||
dns.Address = client.Address
|
||||
if err := PublishDNSUpdate(client.Network, dns); err != nil {
|
||||
errMsgs.ErrorStrings = append(errMsgs.ErrorStrings, err.Error())
|
||||
}
|
||||
|
||||
}
|
||||
if client.Address6 != "" {
|
||||
dns.Address = client.Address6
|
||||
if err := PublishDNSUpdate(client.Network, dns); err != nil {
|
||||
errMsgs.ErrorStrings = append(errMsgs.ErrorStrings, err.Error())
|
||||
}
|
||||
}
|
||||
if len(errMsgs.ErrorStrings) > 0 {
|
||||
return errMsgs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishExtClientDNSUpdate update for extclient name change
|
||||
func PublishExtClientDNSUpdate(old, new models.ExtClient, network string) error {
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSReplaceName,
|
||||
Name: old.ClientID + "." + network,
|
||||
NewName: new.ClientID + "." + network,
|
||||
}
|
||||
if err := PublishDNSUpdate(network, dns); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishDeleteExtClientDNS publish dns update to delete extclient entry
|
||||
func PublishDeleteExtClientDNS(client *models.ExtClient) error {
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSDeleteByName,
|
||||
Name: client.ClientID + "." + client.Network,
|
||||
}
|
||||
if err := PublishDNSUpdate(client.Network, dns); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishCustomDNS publish dns update for new custom dns entry
|
||||
func PublishCustomDNS(entry *models.DNSEntry) error {
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSInsert,
|
||||
Name: entry.Name + "." + entry.Network,
|
||||
//entry.Address6 is never used
|
||||
Address: entry.Address,
|
||||
}
|
||||
if err := PublishDNSUpdate(entry.Network, dns); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PublishHostDNSUpdate publishes dns update on host name change
|
||||
func PublishHostDNSUpdate(old, new *models.Host, networks []string) error {
|
||||
errMsgs := models.DNSError{}
|
||||
for _, network := range networks {
|
||||
dns := models.DNSUpdate{
|
||||
Action: models.DNSReplaceName,
|
||||
Name: old.Name + "." + network,
|
||||
NewName: new.Name + "." + network,
|
||||
}
|
||||
if err := PublishDNSUpdate(network, dns); err != nil {
|
||||
errMsgs.ErrorStrings = append(errMsgs.ErrorStrings, err.Error())
|
||||
}
|
||||
}
|
||||
if len(errMsgs.ErrorStrings) > 0 {
|
||||
return errMsgs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func pushMetricsToExporter(metrics models.Metrics) error {
|
||||
logger.Log(2, "----> Pushing metrics to exporter")
|
||||
data, err := json.Marshal(metrics)
|
||||
if err != nil {
|
||||
return errors.New("failed to marshal metrics: " + err.Error())
|
||||
}
|
||||
if token := mqclient.Publish("metrics_exporter", 2, true, data); !token.WaitTimeout(MQ_TIMEOUT*time.Second) || token.Error() != nil {
|
||||
var err error
|
||||
if token.Error() == nil {
|
||||
err = errors.New("connection timeout")
|
||||
} else {
|
||||
err = token.Error()
|
||||
}
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func getNodeDNS(network string) []models.DNSUpdate {
|
||||
alldns := []models.DNSUpdate{}
|
||||
dns := models.DNSUpdate{}
|
||||
nodes, err := logic.GetNetworkNodes(network)
|
||||
if err != nil {
|
||||
logger.Log(0, "error retreiving network nodes for network", network, err.Error())
|
||||
}
|
||||
for _, node := range nodes {
|
||||
host, err := logic.GetHost(node.HostID.String())
|
||||
if err != nil {
|
||||
logger.Log(0, "error retrieving host for dns update", host.ID.String(), err.Error())
|
||||
continue
|
||||
}
|
||||
dns.Action = models.DNSInsert
|
||||
dns.Name = host.Name + "." + node.Network
|
||||
if node.Address.IP != nil {
|
||||
dns.Address = node.Address.IP.String()
|
||||
alldns = append(alldns, dns)
|
||||
}
|
||||
if node.Address6.IP != nil {
|
||||
dns.Address = node.Address6.IP.String()
|
||||
alldns = append(alldns, dns)
|
||||
}
|
||||
}
|
||||
return alldns
|
||||
}
|
||||
|
||||
func getExtClientDNS(network string) []models.DNSUpdate {
|
||||
alldns := []models.DNSUpdate{}
|
||||
dns := models.DNSUpdate{}
|
||||
clients, err := logic.GetNetworkExtClients(network)
|
||||
if err != nil {
|
||||
logger.Log(0, "error retrieving extclients", err.Error())
|
||||
}
|
||||
for _, client := range clients {
|
||||
dns.Action = models.DNSInsert
|
||||
dns.Name = client.ClientID + "." + client.Network
|
||||
if client.Address != "" {
|
||||
dns.Address = client.Address
|
||||
alldns = append(alldns, dns)
|
||||
}
|
||||
if client.Address6 != "" {
|
||||
dns.Address = client.Address
|
||||
alldns = append(alldns, dns)
|
||||
}
|
||||
}
|
||||
return alldns
|
||||
}
|
||||
|
||||
func getCustomDNS(network string) []models.DNSUpdate {
|
||||
alldns := []models.DNSUpdate{}
|
||||
dns := models.DNSUpdate{}
|
||||
customdns, err := logic.GetCustomDNS(network)
|
||||
if err != nil {
|
||||
logger.Log(0, "error retrieving custom dns entries", err.Error())
|
||||
}
|
||||
for _, custom := range customdns {
|
||||
dns.Action = models.DNSInsert
|
||||
dns.Address = custom.Address
|
||||
dns.Name = custom.Name + "." + custom.Network
|
||||
alldns = append(alldns, dns)
|
||||
}
|
||||
return alldns
|
||||
}
|
||||
|
||||
// sendPeers - retrieve networks, send peer ports to all peers
|
||||
func sendPeers() {
|
||||
|
||||
|
|
@ -144,79 +417,3 @@ func sendPeers() {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ServerStartNotify - notifies all non server nodes to pull changes after a restart
|
||||
func ServerStartNotify() error {
|
||||
nodes, err := logic.GetAllNodes()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for i := range nodes {
|
||||
nodes[i].Action = models.NODE_FORCE_UPDATE
|
||||
if err = NodeUpdate(&nodes[i]); err != nil {
|
||||
logger.Log(1, "error when notifying node", nodes[i].ID.String(), "of a server startup")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// function to collect and store metrics for server nodes
|
||||
//func collectServerMetrics(networks []models.Network) {
|
||||
// if !servercfg.Is_EE {
|
||||
// return
|
||||
// }
|
||||
// if len(networks) > 0 {
|
||||
// for i := range networks {
|
||||
// currentNetworkNodes, err := logic.GetNetworkNodes(networks[i].NetID)
|
||||
// if err != nil {
|
||||
// continue
|
||||
// }
|
||||
// currentServerNodes := logic.GetServerNodes(networks[i].NetID)
|
||||
// if len(currentServerNodes) > 0 {
|
||||
// for i := range currentServerNodes {
|
||||
// if logic.IsLocalServer(¤tServerNodes[i]) {
|
||||
// serverMetrics := logic.CollectServerMetrics(currentServerNodes[i].ID, currentNetworkNodes)
|
||||
// if serverMetrics != nil {
|
||||
// serverMetrics.NodeName = currentServerNodes[i].Name
|
||||
// serverMetrics.NodeID = currentServerNodes[i].ID
|
||||
// serverMetrics.IsServer = "yes"
|
||||
// serverMetrics.Network = currentServerNodes[i].Network
|
||||
// if err = metrics.GetExchangedBytesForNode(¤tServerNodes[i], serverMetrics); err != nil {
|
||||
// logger.Log(1, fmt.Sprintf("failed to update exchanged bytes info for server: %s, err: %v",
|
||||
// currentServerNodes[i].Name, err))
|
||||
// }
|
||||
// updateNodeMetrics(¤tServerNodes[i], serverMetrics)
|
||||
// if err = logic.UpdateMetrics(currentServerNodes[i].ID, serverMetrics); err != nil {
|
||||
// logger.Log(1, "failed to update metrics for server node", currentServerNodes[i].ID)
|
||||
// }
|
||||
// if servercfg.IsMetricsExporter() {
|
||||
// logger.Log(2, "-------------> SERVER METRICS: ", fmt.Sprintf("%+v", serverMetrics))
|
||||
// if err := pushMetricsToExporter(*serverMetrics); err != nil {
|
||||
// logger.Log(2, "failed to push server metrics to exporter: ", err.Error())
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//}
|
||||
|
||||
func pushMetricsToExporter(metrics models.Metrics) error {
|
||||
logger.Log(2, "----> Pushing metrics to exporter")
|
||||
data, err := json.Marshal(metrics)
|
||||
if err != nil {
|
||||
return errors.New("failed to marshal metrics: " + err.Error())
|
||||
}
|
||||
if token := mqclient.Publish("metrics_exporter", 2, true, data); !token.WaitTimeout(MQ_TIMEOUT*time.Second) || token.Error() != nil {
|
||||
var err error
|
||||
if token.Error() == nil {
|
||||
err = errors.New("connection timeout")
|
||||
} else {
|
||||
err = token.Error()
|
||||
}
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -166,13 +166,16 @@ func GetPublicIP(api string) (string, error) {
|
|||
if err != nil {
|
||||
continue
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode == http.StatusOK {
|
||||
var bodyBytes []byte
|
||||
bodyBytes, err = io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
if resp.Body != nil {
|
||||
_ = resp.Body.Close()
|
||||
}
|
||||
continue
|
||||
}
|
||||
_ = resp.Body.Close()
|
||||
endpoint = string(bodyBytes)
|
||||
break
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue