gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-09-08 22:24:17 +08:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #2001 from gravitl/gra-1088_dns_updates

Browse source 
Gra 1088 dns updates
This commit is contained in:
dcarns 2023-02-15 12:55:58 -05:00 • committed by GitHub
commit 92dbfa52a5
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 419 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
controllers/dns.go
View file

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

37
controllers/ext_client.go
View file

@ -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"])

16
controllers/hosts.go
View file

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

36
controllers/node.go
View file

@ -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(&currentNode, 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())
}
}()
}

30
logic/peers.go
View file

@ -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")
@ -522,7 +517,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)
@ -791,7 +785,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
}
@ -962,28 +955,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) {
@ -1122,7 +1093,6 @@ func GetPeerUpdateForRelayedNode(node *models.Node, udppeers map[string]string)
})
peerUpdate.Peers = peers
peerUpdate.ServerAddrs = serverNodeAddresses
peerUpdate.DNS = getPeerDNS(node.Network)
return peerUpdate, nil
}

39
models/dnsEntry.go
View file

@ -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"`

25
models/mqtt.go
View file

@ -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
@ -62,11 +60,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
View file

@ -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(&currentServerNodes[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(&currentServerNodes[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(&currentServerNodes[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
}