use GetHost vice GetHostByNodeID

controllers/relay.go

@@ -43,8 +43,15 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
 		return
 	}
+	relayHost, err := logic.GetHost(relayNode.HostID.String())
+	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to retrieve host for node [%s] on network [%s]: %v", relayRequest.NodeID, relayRequest.NetID, err))
+		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
+		return
+	}
 	relay := models.Client{
-		Host: *logic.GetHostByNodeID(params["nodeid"]),
+		Host: *relayHost,
 		Node: relayNode,
 	}
 	peers, err := logic.GetNetworkClients(relay.Node.Network)
@@ -94,26 +101,28 @@ func deleteRelay(w http.ResponseWriter, r *http.Request) {
 	logger.Log(1, r.Header.Get("user"), "deleted relay server", nodeid, "on network", netid)
 	go func() {
 		//update relayHost node
-		relayHost := logic.GetHostByNodeID(node.ID.String())
-		if err := mq.NodeUpdate(&node); err != nil {
-			logger.Log(1, "relay node update", relayHost.Name, "on network", node.Network, ": ", err.Error())
-		}
-		for _, relayedClient := range updateClients {
-			err = mq.NodeUpdate(&relayedClient.Node)
-			if err != nil {
-				logger.Log(1, "relayed node update ", relayedClient.Node.ID.String(), "on network", relayedClient.Node.Network, ": ", err.Error())
+		relayHost, err := logic.GetHost(node.HostID.String())
+		if err == nil {
+			if err := mq.NodeUpdate(&node); err != nil {
+				logger.Log(1, "relay node update", relayHost.Name, "on network", node.Network, ": ", err.Error())
+			}
+			for _, relayedClient := range updateClients {
+				err = mq.NodeUpdate(&relayedClient.Node)
+				if err != nil {
+					logger.Log(1, "relayed node update ", relayedClient.Node.ID.String(), "on network", relayedClient.Node.Network, ": ", err.Error())
 
+				}
+			}
+			peers, err := logic.GetNetworkClients(node.Network)
+			if err != nil {
+				logger.Log(0, "error getting network nodes: ", err.Error())
+				logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
+				return
+			}
+			clients := peers
+			for _, client := range clients {
+				mq.PubPeerUpdate(&client, nil, peers)
 			}
-		}
-		peers, err := logic.GetNetworkClients(node.Network)
-		if err != nil {
-			logger.Log(0, "error getting network nodes: ", err.Error())
-			logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
-			return
-		}
-		clients := peers
-		for _, client := range clients {
-			mq.PubPeerUpdate(&client, nil, peers)
 		}
 	}()
 	logger.Log(1, r.Header.Get("user"), "deleted relay on node", node.ID.String(), "on network", node.Network)

logic/nodes.go

@@ -49,11 +49,14 @@ func GetNetworkClients(network string) ([]models.Client, error) {
 		return []models.Client{}, err
 	}
 	for _, node := range nodes {
-		client := models.Client{
-			Node: node,
-			Host: *GetHostByNodeID(node.ID.String()),
+		host, err := GetHost(node.HostID.String())
+		if err == nil {
+			client := models.Client{
+				Node: node,
+				Host: *host,
+			}
+			clients = append(clients, client)
 		}
-		clients = append(clients, client)
 	}
 	return clients, nil
 }

logic/peers.go

@@ -193,11 +193,14 @@ func GetPeerUpdateForHost(ctx context.Context, network string, host *models.Host
 					}
 				}
 				if peer.IsEgressGateway {
-					allowedips = append(allowedips, getEgressIPs(
-						&models.Client{
-							Host: *GetHostByNodeID(peer.ID.String()),
-							Node: peer,
-						})...)
+					host, err := GetHost(peer.HostID.String())
+					if err == nil {
+						allowedips = append(allowedips, getEgressIPs(
+							&models.Client{
+								Host: *host,
+								Node: peer,
+							})...)
+					}
 				}
 				if peer.Action != models.NODE_DELETE &&
 					!peer.PendingDelete &&
@@ -628,12 +631,15 @@ func getNodeAllowedIPs(peer, node *models.Node) []net.IPNet {
 	// handle egress gateway peers
 	if peer.IsEgressGateway {
 		//hasGateway = true
-		egressIPs := getEgressIPs(
-			&models.Client{
-				Host: *GetHostByNodeID(peer.ID.String()),
-				Node: *peer,
-			})
-		allowedips = append(allowedips, egressIPs...)
+		host, err := GetHost(peer.HostID.String())
+		if err == nil {
+			egressIPs := getEgressIPs(
+				&models.Client{
+					Host: *host,
+					Node: *peer,
+				})
+			allowedips = append(allowedips, egressIPs...)
+		}
 	}
 	if peer.IsRelay {
 		for _, relayed := range peer.RelayedNodes {
@@ -783,26 +789,29 @@ func getRelayAllowedIPs(peer *models.Client) []net.IPNet {
 			relayedNode.Address.Mask = net.CIDRMask(128, 128)
 			relayIPs = append(relayIPs, relayedNode.Address6)
 		}
-		if relayedNode.IsRelay {
-			relayIPs = append(relayIPs, getRelayAllowedIPs(
-				&models.Client{
-					Host: *GetHostByNodeID(relayedNode.ID.String()),
-					Node: relayedNode,
-				})...)
-		}
-		if relayedNode.IsEgressGateway {
-			relayIPs = append(relayIPs, getEgressIPs(
-				&models.Client{
-					Host: *GetHostByNodeID(relayedNode.ID.String()),
-					Node: relayedNode,
-				})...)
-		}
-		if relayedNode.IsIngressGateway {
-			relayIPs = append(relayIPs, getIngressIPs(
-				&models.Client{
-					Host: *GetHostByNodeID(relayedNode.ID.String()),
-					Node: relayedNode,
-				})...)
+		host, err := GetHost(relayedNode.HostID.String())
+		if err == nil {
+			if relayedNode.IsRelay {
+				relayIPs = append(relayIPs, getRelayAllowedIPs(
+					&models.Client{
+						Host: *host,
+						Node: relayedNode,
+					})...)
+			}
+			if relayedNode.IsEgressGateway {
+				relayIPs = append(relayIPs, getEgressIPs(
+					&models.Client{
+						Host: *host,
+						Node: relayedNode,
+					})...)
+			}
+			if relayedNode.IsIngressGateway {
+				relayIPs = append(relayIPs, getIngressIPs(
+					&models.Client{
+						Host: *host,
+						Node: relayedNode,
+					})...)
+			}
 		}
 	}
 	return relayIPs

logic/relay.go

@@ -80,11 +80,13 @@ func SetRelayedNodes(setRelayed bool, relay string, relayed []string) []models.C
 			logger.Log(0, "setRelayedNodes.Insert", err.Error())
 			continue
 		}
-		host := GetHostByNodeID(node.ID.String())
-		returnnodes = append(returnnodes, models.Client{
-			Host: *host,
-			Node: node,
-		})
+		host, err := GetHost(node.HostID.String())
+		if err == nil {
+			returnnodes = append(returnnodes, models.Client{
+				Host: *host,
+				Node: node,
+			})
+		}
 	}
 	return returnnodes
 }
@@ -158,8 +160,12 @@ func peerUpdateForRelayed(client *models.Client, peers []models.Client) []wgtype
 		logger.Log(0, "error retrieving relay node", err.Error())
 		return []wgtypes.PeerConfig{}
 	}
+	host, err := GetHost(relayNode.HostID.String())
+	if err != nil {
+		return []wgtypes.PeerConfig{}
+	}
 	relay := models.Client{
-		Host: *GetHostByNodeID(relayNode.ID.String()),
+		Host: *host,
 		Node: relayNode,
 	}
 	for _, peer := range peers {