mirror of
https://github.com/gravitl/netmaker.git
synced 2026-01-31 16:19:57 +08:00
c643a50b67
* force update host dns field if node is acting as inet gw * add old acl support checks * move auto relay migration to pro pkg * add check to avoid unsetting relayed node * simplify auto assign gw logic * send auto assign update on un relay * set checking time to latest on updates * fix HA auto Relay logic * add relay node metrics to peer signal * move auto relay peer check * publish host peer update * check and unset unrelayed auto peers * use relay node mutex to avoid rac condition * reset autorelayed peers on auto assign gw
660 lines
20 KiB
Go
660 lines
20 KiB
Go
package controllers
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
|
|
"github.com/gorilla/mux"
|
|
controller "github.com/gravitl/netmaker/controllers"
|
|
"github.com/gravitl/netmaker/db"
|
|
"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"
|
|
"github.com/gravitl/netmaker/schema"
|
|
"github.com/gravitl/netmaker/servercfg"
|
|
"golang.org/x/exp/slog"
|
|
)
|
|
|
|
// AutoRelayHandlers - handlers for AutoRelay
|
|
func AutoRelayHandlers(r *mux.Router) {
|
|
r.HandleFunc("/api/v1/node/{nodeid}/auto_relay", controller.Authorize(true, false, "host", http.HandlerFunc(getAutoRelayGws))).
|
|
Methods(http.MethodGet)
|
|
r.HandleFunc("/api/v1/node/{nodeid}/auto_relay", logic.SecurityCheck(true, http.HandlerFunc(setAutoRelay))).
|
|
Methods(http.MethodPost)
|
|
r.HandleFunc("/api/v1/node/{nodeid}/auto_relay", logic.SecurityCheck(true, http.HandlerFunc(unsetAutoRelay))).
|
|
Methods(http.MethodDelete)
|
|
r.HandleFunc("/api/v1/node/{network}/auto_relay/reset", logic.SecurityCheck(true, http.HandlerFunc(resetAutoRelayGw))).
|
|
Methods(http.MethodPost)
|
|
r.HandleFunc("/api/v1/node/{nodeid}/auto_relay_me", controller.Authorize(true, false, "host", http.HandlerFunc(autoRelayME))).
|
|
Methods(http.MethodPost)
|
|
r.HandleFunc("/api/v1/node/{nodeid}/auto_relay_me", controller.Authorize(true, false, "host", http.HandlerFunc(autoRelayMEUpdate))).
|
|
Methods(http.MethodPut)
|
|
r.HandleFunc("/api/v1/node/{nodeid}/auto_relay_check", controller.Authorize(true, false, "host", http.HandlerFunc(checkautoRelayCtx))).
|
|
Methods(http.MethodGet)
|
|
}
|
|
|
|
// @Summary Get auto relay nodes
|
|
// @Router /api/v1/node/{nodeid}/auto_relay [get]
|
|
// @Tags PRO
|
|
// @Param nodeid path string true "Node ID"
|
|
// @Success 200 {object} models.Node
|
|
// @Failure 400 {object} models.ErrorResponse
|
|
// @Failure 404 {object} models.ErrorResponse
|
|
func getAutoRelayGws(w http.ResponseWriter, r *http.Request) {
|
|
var params = mux.Vars(r)
|
|
nodeid := params["nodeid"]
|
|
// confirm host exists
|
|
node, err := logic.GetNodeByID(nodeid)
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
autoRelayNodes := proLogic.DoesAutoRelayExist(node.Network)
|
|
if len(autoRelayNodes) == 0 {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("autorelay node not found"), "notfound"),
|
|
)
|
|
return
|
|
}
|
|
defaultPolicy, err := logic.GetDefaultPolicy(models.NetworkID(node.Network), models.DevicePolicy)
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
|
return
|
|
}
|
|
returnautoRelayNodes := []models.Node{}
|
|
if !defaultPolicy.Enabled {
|
|
for _, autoRelayNode := range autoRelayNodes {
|
|
if logic.IsPeerAllowed(node, autoRelayNode, false) {
|
|
returnautoRelayNodes = append(returnautoRelayNodes, autoRelayNode)
|
|
}
|
|
}
|
|
} else {
|
|
returnautoRelayNodes = autoRelayNodes
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
logic.ReturnSuccessResponseWithJson(w, r, returnautoRelayNodes, "get autorelay node successfully")
|
|
}
|
|
|
|
// @Summary Create AutoRelay node
|
|
// @Router /api/v1/node/{nodeid}/auto_relay [post]
|
|
// @Tags PRO
|
|
// @Param nodeid path string true "Node ID"
|
|
// @Success 200 {object} models.Node
|
|
// @Failure 400 {object} models.ErrorResponse
|
|
// @Failure 500 {object} models.ErrorResponse
|
|
func setAutoRelay(w http.ResponseWriter, r *http.Request) {
|
|
var params = mux.Vars(r)
|
|
nodeid := params["nodeid"]
|
|
// confirm host exists
|
|
node, err := logic.GetNodeByID(nodeid)
|
|
if err != nil {
|
|
slog.Error("failed to get node:", "error", err.Error())
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
err = proLogic.CreateAutoRelay(node)
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
|
return
|
|
}
|
|
go mq.PublishPeerUpdate(false)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
logic.ReturnSuccessResponseWithJson(w, r, node, "created autorelay successfully")
|
|
}
|
|
|
|
// @Summary Reset AutoRelay for a network
|
|
// @Router /api/v1/node/{network}/auto_relay/reset [post]
|
|
// @Tags PRO
|
|
// @Param network path string true "Network ID"
|
|
// @Success 200 {object} models.SuccessResponse
|
|
// @Failure 500 {object} models.ErrorResponse
|
|
func resetAutoRelayGw(w http.ResponseWriter, r *http.Request) {
|
|
var params = mux.Vars(r)
|
|
net := params["network"]
|
|
nodes, err := logic.GetNetworkNodes(net)
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
|
return
|
|
}
|
|
for _, node := range nodes {
|
|
if len(node.AutoRelayedPeers) > 0 {
|
|
if node.Mutex != nil {
|
|
node.Mutex.Lock()
|
|
}
|
|
node.AutoRelayedPeers = make(map[string]string)
|
|
if node.Mutex != nil {
|
|
node.Mutex.Unlock()
|
|
}
|
|
logic.UpsertNode(&node)
|
|
}
|
|
}
|
|
go mq.PublishPeerUpdate(false)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
logic.ReturnSuccessResponse(w, r, "autorelay has been reset successfully")
|
|
}
|
|
|
|
// @Summary Delete autorelay node
|
|
// @Router /api/v1/node/{nodeid}/auto_relay [delete]
|
|
// @Tags PRO
|
|
// @Param nodeid path string true "Node ID"
|
|
// @Success 200 {object} models.Node
|
|
// @Failure 400 {object} models.ErrorResponse
|
|
// @Failure 500 {object} models.ErrorResponse
|
|
func unsetAutoRelay(w http.ResponseWriter, r *http.Request) {
|
|
var params = mux.Vars(r)
|
|
nodeid := params["nodeid"]
|
|
// confirm host exists
|
|
node, err := logic.GetNodeByID(nodeid)
|
|
if err != nil {
|
|
slog.Error("failed to get node:", "error", err.Error())
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
node.IsAutoRelay = false
|
|
// Reset AutoRelayed Peers
|
|
err = logic.UpsertNode(&node)
|
|
if err != nil {
|
|
slog.Error("failed to upsert node", "node", node.ID.String(), "error", err)
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
|
return
|
|
}
|
|
if servercfg.CacheEnabled() {
|
|
proLogic.RemoveAutoRelayFromCache(node.Network)
|
|
}
|
|
go func() {
|
|
proLogic.ResetAutoRelay(&node)
|
|
mq.PublishPeerUpdate(false)
|
|
}()
|
|
w.Header().Set("Content-Type", "application/json")
|
|
logic.ReturnSuccessResponseWithJson(w, r, node, "deleted autorelay successfully")
|
|
}
|
|
|
|
// @Summary AutoRelay me
|
|
// @Router /api/v1/node/{nodeid}/auto_relay_me [post]
|
|
// @Tags PRO
|
|
// @Param nodeid path string true "Node ID"
|
|
// @Accept json
|
|
// @Param body body models.AutoRelayMeReq true "AutoRelay request"
|
|
// @Success 200 {object} models.SuccessResponse
|
|
// @Failure 400 {object} models.ErrorResponse
|
|
// @Failure 500 {object} models.ErrorResponse
|
|
func autoRelayME(w http.ResponseWriter, r *http.Request) {
|
|
var params = mux.Vars(r)
|
|
nodeid := params["nodeid"]
|
|
// confirm host exists
|
|
node, err := logic.GetNodeByID(nodeid)
|
|
if err != nil {
|
|
logger.Log(0, r.Header.Get("user"), "failed to get node:", err.Error())
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
host, err := logic.GetHost(node.HostID.String())
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
var autoRelayReq models.AutoRelayMeReq
|
|
err = json.NewDecoder(r.Body).Decode(&autoRelayReq)
|
|
if err != nil {
|
|
logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
|
|
autoRelayNode, err := logic.GetNodeByID(autoRelayReq.AutoRelayGwID)
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
fmt.Errorf("req-from: %s, autorelay node doesn't exist in the network", host.Name),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
|
|
var sendPeerUpdate bool
|
|
peerNode, err := logic.GetNodeByID(autoRelayReq.NodeID)
|
|
if err != nil {
|
|
slog.Error("peer not found: ", "nodeid", autoRelayReq.NodeID, "error", err)
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("peer not found"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
eli, _ := (&schema.Egress{Network: node.Network}).ListByNetwork(db.WithContext(context.TODO()))
|
|
acls, _ := logic.ListAclsByNetwork(models.NetworkID(node.Network))
|
|
logic.GetNodeEgressInfo(&node, eli, acls)
|
|
logic.GetNodeEgressInfo(&peerNode, eli, acls)
|
|
logic.GetNodeEgressInfo(&autoRelayNode, eli, acls)
|
|
if peerNode.IsAutoRelay {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("peer is acting as autorelay"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if node.IsAutoRelay {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("node is acting as autorelay"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if peerNode.IsAutoRelay {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("peer is acting as autorelay"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if node.IsRelayed && node.RelayedBy == peerNode.ID.String() {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("node is relayed by peer node"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if node.IsRelay && peerNode.RelayedBy == node.ID.String() {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("node acting as relay for the peer node"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if (node.InternetGwID != "" && autoRelayNode.IsInternetGateway && node.InternetGwID != autoRelayNode.ID.String()) ||
|
|
(peerNode.InternetGwID != "" && autoRelayNode.IsInternetGateway && peerNode.InternetGwID != autoRelayNode.ID.String()) {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
errors.New("node using a internet gw by the peer node"),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
if node.IsInternetGateway && peerNode.InternetGwID == node.ID.String() {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
errors.New("node acting as internet gw for the peer node"),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
if node.InternetGwID != "" && node.InternetGwID == peerNode.ID.String() {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
errors.New("node using a internet gw by the peer node"),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
err = proLogic.SetAutoRelayCtx(autoRelayNode, node, peerNode)
|
|
if err != nil {
|
|
slog.Debug("failed to create autorelay", "id", node.ID.String(),
|
|
"network", node.Network, "error", err)
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(fmt.Errorf("failed to create autorelay: %v", err), "internal"),
|
|
)
|
|
return
|
|
}
|
|
slog.Info(
|
|
"[auto-relay] created relay on node",
|
|
"node",
|
|
node.ID.String(),
|
|
"network",
|
|
node.Network,
|
|
)
|
|
sendPeerUpdate = true
|
|
|
|
if sendPeerUpdate {
|
|
go mq.PublishPeerUpdate(false)
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
logic.ReturnSuccessResponse(w, r, "relayed successfully")
|
|
}
|
|
|
|
// @Summary AutoRelay me
|
|
// @Router /api/v1/node/{nodeid}/auto_relay_me [put]
|
|
// @Tags PRO
|
|
// @Param nodeid path string true "Node ID"
|
|
// @Accept json
|
|
// @Param body body models.AutoRelayMeReq true "AutoRelay request"
|
|
// @Success 200 {object} models.SuccessResponse
|
|
// @Failure 400 {object} models.ErrorResponse
|
|
// @Failure 500 {object} models.ErrorResponse
|
|
func autoRelayMEUpdate(w http.ResponseWriter, r *http.Request) {
|
|
var params = mux.Vars(r)
|
|
nodeid := params["nodeid"]
|
|
// confirm host exists
|
|
node, err := logic.GetNodeByID(nodeid)
|
|
if err != nil {
|
|
logger.Log(0, r.Header.Get("user"), "failed to get node:", err.Error())
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
|
|
host, err := logic.GetHost(node.HostID.String())
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
var autoRelayReq models.AutoRelayMeReq
|
|
err = json.NewDecoder(r.Body).Decode(&autoRelayReq)
|
|
if err != nil {
|
|
logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
if autoRelayReq.AutoRelayGwID == "" {
|
|
if node.AutoAssignGateway {
|
|
// unset current gw
|
|
if node.RelayedBy != "" {
|
|
// unset relayed node from the curr relay
|
|
currRelayNode, err := logic.GetNodeByID(node.RelayedBy)
|
|
if err == nil {
|
|
if currRelayNode.Mutex != nil {
|
|
currRelayNode.Mutex.Lock()
|
|
}
|
|
newRelayedNodes := logic.RemoveAllFromSlice(currRelayNode.RelayedNodes, node.ID.String())
|
|
currRelayNode.RelayedNodes = newRelayedNodes
|
|
logic.UpsertNode(&currRelayNode)
|
|
node.RelayedBy = ""
|
|
node.IsRelayed = false
|
|
logic.UpsertNode(&node)
|
|
if currRelayNode.Mutex != nil {
|
|
currRelayNode.Mutex.Unlock()
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
peerNode, err := logic.GetNodeByID(autoRelayReq.NodeID)
|
|
if err != nil {
|
|
slog.Error("peer not found: ", "nodeid", autoRelayReq.NodeID, "error", err)
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("peer not found"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
delete(node.AutoRelayedPeers, peerNode.ID.String())
|
|
delete(peerNode.AutoRelayedPeers, node.ID.String())
|
|
logic.UpsertNode(&node)
|
|
logic.UpsertNode(&peerNode)
|
|
}
|
|
allNodes, err := logic.GetAllNodes()
|
|
if err == nil {
|
|
mq.PublishSingleHostPeerUpdate(host, allNodes, nil, nil, false, nil)
|
|
}
|
|
go mq.PublishPeerUpdate(false)
|
|
if node.AutoAssignGateway {
|
|
mq.HostUpdate(&models.HostUpdate{Action: models.CheckAutoAssignGw, Host: *host, Node: node})
|
|
}
|
|
logic.ReturnSuccessResponse(w, r, "unrelayed successfully")
|
|
return
|
|
}
|
|
autoRelayNode, err := logic.GetNodeByID(autoRelayReq.AutoRelayGwID)
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
fmt.Errorf("req-from: %s, autorelay node doesn't exist in the network", host.Name),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
if !autoRelayNode.IsGw {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
fmt.Errorf(" autorelay node is not a gw"),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
if node.AutoAssignGateway {
|
|
if node.RelayedBy != autoRelayReq.AutoRelayGwID {
|
|
if node.RelayedBy != "" {
|
|
// unset relayed node from the curr relay
|
|
currRelayNode, err := logic.GetNodeByID(node.RelayedBy)
|
|
if err == nil {
|
|
newRelayedNodes := logic.RemoveAllFromSlice(currRelayNode.RelayedNodes, node.ID.String())
|
|
logic.UpdateRelayNodes(currRelayNode.ID.String(), currRelayNode.RelayedNodes, newRelayedNodes)
|
|
}
|
|
}
|
|
newNodes := []string{node.ID.String()}
|
|
newNodes = append(newNodes, autoRelayNode.RelayedNodes...)
|
|
logic.UpdateRelayNodes(autoRelayNode.ID.String(), autoRelayNode.RelayedNodes, newNodes)
|
|
go mq.PublishPeerUpdate(false)
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
logic.ReturnSuccessResponse(w, r, "relayed successfully")
|
|
return
|
|
}
|
|
peerNode, err := logic.GetNodeByID(autoRelayReq.NodeID)
|
|
if err != nil {
|
|
slog.Error("peer not found: ", "nodeid", autoRelayReq.NodeID, "error", err)
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("peer not found"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if len(node.AutoRelayedPeers) == 0 {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(errors.New("node is not auto relayed"), "badrequest"))
|
|
return
|
|
}
|
|
|
|
if !autoRelayNode.IsAutoRelay {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(errors.New("requested node is not a auto relay node"), "badrequest"))
|
|
return
|
|
}
|
|
if node.AutoRelayedPeers[peerNode.ID.String()] == peerNode.AutoRelayedPeers[node.ID.String()] {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(errors.New("already using requested relay node"), "badrequest"))
|
|
return
|
|
}
|
|
node.AutoRelayedPeers[peerNode.ID.String()] = autoRelayReq.AutoRelayGwID
|
|
peerNode.AutoRelayedPeers[node.ID.String()] = autoRelayReq.AutoRelayGwID
|
|
logic.UpsertNode(&node)
|
|
slog.Info(
|
|
"[auto-relay] created relay on node",
|
|
"node",
|
|
node.ID.String(),
|
|
"network",
|
|
node.Network,
|
|
)
|
|
go mq.PublishPeerUpdate(false)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
logic.ReturnSuccessResponse(w, r, "relayed successfully")
|
|
}
|
|
|
|
// @Summary checkautoRelayCtx
|
|
// @Router /api/v1/node/{nodeid}/auto_relay_check [get]
|
|
// @Tags PRO
|
|
// @Param nodeid path string true "Node ID"
|
|
// @Accept json
|
|
// @Param body body models.AutoRelayMeReq true "autorelay request"
|
|
// @Success 200 {object} models.SuccessResponse
|
|
// @Failure 400 {object} models.ErrorResponse
|
|
// @Failure 500 {object} models.ErrorResponse
|
|
func checkautoRelayCtx(w http.ResponseWriter, r *http.Request) {
|
|
var params = mux.Vars(r)
|
|
nodeid := params["nodeid"]
|
|
// confirm host exists
|
|
node, err := logic.GetNodeByID(nodeid)
|
|
if err != nil {
|
|
logger.Log(0, r.Header.Get("user"), "failed to get node:", err.Error())
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
host, err := logic.GetHost(node.HostID.String())
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
var autoRelayReq models.AutoRelayMeReq
|
|
err = json.NewDecoder(r.Body).Decode(&autoRelayReq)
|
|
if err != nil {
|
|
logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
|
return
|
|
}
|
|
autoRelayNode, err := logic.GetNodeByID(autoRelayReq.AutoRelayGwID)
|
|
if err != nil {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
fmt.Errorf("req-from: %s, autorelay node doesn't exist in the network", host.Name),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
|
|
peerNode, err := logic.GetNodeByID(autoRelayReq.NodeID)
|
|
if err != nil {
|
|
slog.Error("peer not found: ", "nodeid", autoRelayReq.NodeID, "error", err)
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("peer not found"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
eli, _ := (&schema.Egress{Network: node.Network}).ListByNetwork(db.WithContext(context.TODO()))
|
|
acls, _ := logic.ListAclsByNetwork(models.NetworkID(node.Network))
|
|
logic.GetNodeEgressInfo(&node, eli, acls)
|
|
logic.GetNodeEgressInfo(&peerNode, eli, acls)
|
|
logic.GetNodeEgressInfo(&autoRelayNode, eli, acls)
|
|
if peerNode.IsAutoRelay {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("peer is acting as autorelay"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if node.IsAutoRelay {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("node is acting as autorelay"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if peerNode.IsAutoRelay {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("peer is acting as autorelay"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if node.IsRelayed && node.RelayedBy == peerNode.ID.String() {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("node is relayed by peer node"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if node.IsRelay && peerNode.RelayedBy == node.ID.String() {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(errors.New("node acting as relay for the peer node"), "badrequest"),
|
|
)
|
|
return
|
|
}
|
|
if (node.InternetGwID != "" && autoRelayNode.IsInternetGateway && node.InternetGwID != autoRelayNode.ID.String()) ||
|
|
(peerNode.InternetGwID != "" && autoRelayNode.IsInternetGateway && peerNode.InternetGwID != autoRelayNode.ID.String()) {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
errors.New("node using a internet gw by the peer node"),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
if node.IsInternetGateway && peerNode.InternetGwID == node.ID.String() {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
errors.New("node acting as internet gw for the peer node"),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
if node.InternetGwID != "" && node.InternetGwID == peerNode.ID.String() {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
errors.New("node using a internet gw by the peer node"),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
if ok := logic.IsPeerAllowed(node, peerNode, true); !ok {
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(
|
|
errors.New("peers are not allowed to communicate"),
|
|
"badrequest",
|
|
),
|
|
)
|
|
return
|
|
}
|
|
|
|
err = proLogic.CheckAutoRelayCtx(autoRelayNode, node, peerNode)
|
|
if err != nil {
|
|
slog.Error("autorelay ctx cannot be set ", "error", err)
|
|
logic.ReturnErrorResponse(
|
|
w,
|
|
r,
|
|
logic.FormatError(fmt.Errorf("autorelay ctx cannot be set: %v", err), "internal"),
|
|
)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
logic.ReturnSuccessResponse(w, r, "autorelay can be set")
|
|
}
|