set failOver ctx

logic/hosts.go

@@ -156,20 +156,6 @@ func GetHost(hostid string) (*models.Host, error) {
 	return &h, nil
 }
 
-// GetHostByPubKey - gets a host from db given pubkey
-func GetHostByPubKey(hostPubKey string) (models.Host, error) {
-	hosts, err := GetAllHosts()
-	if err != nil {
-		return models.Host{}, err
-	}
-	for _, host := range hosts {
-		if host.PublicKey.String() == hostPubKey {
-			return host, nil
-		}
-	}
-	return models.Host{}, errors.New("host not found")
-}
-
 // CreateHost - creates a host if not exist
 func CreateHost(h *models.Host) error {
 	hosts, hErr := GetAllHosts()

pro/controllers/failover.go

@@ -8,14 +8,14 @@ import (
 	controller "github.com/gravitl/netmaker/controllers"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
-	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/mq"
 	proLogic "github.com/gravitl/netmaker/pro/logic"
 	"golang.org/x/exp/slog"
 )
 
 type FailOverMeReq struct {
-	PeerPubKey string `json:"peer_pub_key"`
+	MyNodeID   string `json:"my_node_id"`
+	PeerNodeID string `json:"peer_node_id"`
 }
 
 // RelayHandlers - handle Pro Relays
@@ -36,11 +36,11 @@ func FailOverHandler(r *mux.Router) {
 //				200: nodeResponse
 func failOverME(w http.ResponseWriter, r *http.Request) {
 	var params = mux.Vars(r)
-	hostid := params["hostid"]
+	nodeid := params["nodeid"]
 	// confirm host exists
-	host, err := logic.GetHost(hostid)
+	node, err := logic.GetNodeByID(nodeid)
 	if err != nil {
-		logger.Log(0, r.Header.Get("user"), "failed to get host:", err.Error())
+		logger.Log(0, r.Header.Get("user"), "failed to get node:", err.Error())
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
 		return
 	}
@@ -51,50 +51,45 @@ func failOverME(w http.ResponseWriter, r *http.Request) {
 	var failOverReq FailOverMeReq
 	err = json.NewDecoder(r.Body).Decode(&failOverReq)
 	if err != nil {
-		logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
+		slog.Error("error decoding request body: ", "error", err.Error())
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
 		return
 	}
-	var sendPeerUpdate bool
 	allNodes, err := logic.GetAllNodes()
 	if err != nil {
 		slog.Error("failed to get all nodes", "error", err)
 	}
-	logic.GetHost()
-	for _, nodeID := range host.Nodes {
-		node, err := logic.GetNodeByID(nodeID)
-		if err != nil {
-			slog.Error("couldn't find node", "id", nodeID, "error", err)
-			continue
-		}
-		if node.IsRelayed {
-			continue
-		}
-		// get auto relay Host in this network
-		failOverNode, err := proLogic.GetFailOverNode(node.Network, allNodes)
-		if err != nil {
-			slog.Error("auto relay not found", "network", node.Network)
-			continue
-		}
-		peerHost, err := logic.GetHostByPubKey(failOverReq.PeerPubKey)
-		if err != nil {
-
-		}
-
-		err = proLogic.SetFailOverCtx(failOverNode, node, models.Node{})
-		if err != nil {
-			slog.Error("failed to create relay:", "id", node.ID.String(),
-				"network", node.Network, "error", err)
-			continue
-		}
-		slog.Info("[auto-relay] created relay on node", "node", node.ID.String(), "network", node.Network)
-		sendPeerUpdate = true
+	peerNode, err := logic.GetNodeByID(failOverReq.PeerNodeID)
+	if err != nil {
+		slog.Error("failed to get node", "error", err.Error())
+		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+		return
 	}
 
-	if sendPeerUpdate {
-		go mq.PublishPeerUpdate()
+	if peerNode.Network != node.Network {
+		slog.Error("node and peer aren't of same network", "error", err.Error())
+		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+		return
 	}
-
+	if node.IsRelayed {
+		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+		return
+	}
+	failOverNode, err := proLogic.GetFailOverNode(node.Network, allNodes)
+	if err != nil {
+		slog.Error("auto relay not found", "network", node.Network)
+		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
+		return
+	}
+	err = proLogic.SetFailOverCtx(failOverNode, node, peerNode)
+	if err != nil {
+		slog.Error("failed to create relay:", "id", node.ID.String(),
+			"network", node.Network, "error", err)
+		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
+		return
+	}
+	slog.Info("[auto-relay] created relay on node", "node", node.ID.String(), "network", node.Network)
+	go mq.PublishPeerUpdate()
 	w.Header().Set("Content-Type", "application/json")
 	logic.ReturnSuccessResponse(w, r, "relayed successfully")
 }

pro/logic/failover.go

@@ -8,7 +8,7 @@ import (
 )
 
 func SetFailOverCtx(failOverNode, victimNode, peerNode models.Node) error {
-	failOverNode.FailOverPeers[victimNode.ID.String()] = struct{}{}
+	peerNode.FailOverPeers[victimNode.ID.String()] = struct{}{}
 	victimNode.FailedOverBy = failOverNode.ID
 	if err := logic.UpsertNode(&failOverNode); err != nil {
 		return err
@@ -16,6 +16,9 @@ func SetFailOverCtx(failOverNode, victimNode, peerNode models.Node) error {
 	if err := logic.UpsertNode(&victimNode); err != nil {
 		return err
 	}
+	if err := logic.UpsertNode(&peerNode); err != nil {
+		return err
+	}
 	return nil
 }