remove grpc

controllers/auth_grpc.go

@@ -1,182 +0,0 @@
-package controller
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-
-	"github.com/gravitl/netmaker/database"
-	"github.com/gravitl/netmaker/functions"
-	nodepb "github.com/gravitl/netmaker/grpc"
-	"github.com/gravitl/netmaker/logic"
-	"github.com/gravitl/netmaker/models"
-	"golang.org/x/crypto/bcrypt"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
-)
-
-// AuthServerUnaryInterceptor - auth unary interceptor logic
-func AuthServerUnaryInterceptor(ctx context.Context,
-	req interface{},
-	info *grpc.UnaryServerInfo,
-	handler grpc.UnaryHandler) (interface{}, error) {
-	// Skip authorize when GetJWT is requested
-
-	if info.FullMethod != "/node.NodeService/Login" {
-		if info.FullMethod != "/node.NodeService/CreateNode" {
-
-			err := grpcAuthorize(ctx)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	// Calls the handler
-	h, err := handler(ctx, req)
-
-	return h, err
-}
-
-// AuthServerStreamInterceptor - auth stream interceptor
-func AuthServerStreamInterceptor(
-	srv interface{},
-	stream grpc.ServerStream,
-	info *grpc.StreamServerInfo,
-	handler grpc.StreamHandler,
-) error {
-	if info.FullMethod == "/node.NodeService/GetPeers" {
-		if err := grpcAuthorize(stream.Context()); err != nil {
-			return err
-		}
-	}
-
-	// Calls the handler
-	return handler(srv, stream)
-}
-
-func grpcAuthorize(ctx context.Context) error {
-
-	md, ok := metadata.FromIncomingContext(ctx)
-
-	if !ok {
-		return status.Errorf(codes.InvalidArgument, "Retrieving metadata is failed")
-	}
-
-	authHeader, ok := md["authorization"]
-	if !ok {
-		return status.Errorf(codes.Unauthenticated, "Authorization token is not supplied")
-	}
-
-	authToken := authHeader[0]
-
-	nodeID, _, network, err := logic.VerifyToken(authToken)
-	if err != nil {
-		return err
-	}
-
-	networkexists, err := functions.NetworkExists(network)
-
-	if err != nil {
-		return status.Errorf(codes.Unauthenticated, "Unauthorized. Network does not exist: "+network)
-	}
-	node, err := logic.GetNodeByID(nodeID)
-	if database.IsEmptyRecord(err) {
-		// == DELETE replace logic after 2 major version updates ==
-		if node, err = logic.GetDeletedNodeByID(node.ID); err == nil {
-			if functions.RemoveDeletedNode(node.ID) {
-				return status.Errorf(codes.Unauthenticated, models.NODE_DELETE)
-			}
-			return status.Errorf(codes.Unauthenticated, "Node does not exist.")
-		}
-		return status.Errorf(codes.Unauthenticated, "Empty record")
-	}
-	if err != nil || node.ID == "" {
-		return status.Errorf(codes.Unauthenticated, "Node does not exist.")
-	}
-
-	if !networkexists {
-		return status.Errorf(codes.Unauthenticated, "Network does not exist.")
-	}
-	return nil
-}
-
-// Login - node authenticates using its password and retrieves a JWT for authorization.
-func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-
-	var reqNode, err = getNodeFromRequestData(req.Data)
-	if err != nil {
-		return nil, err
-	}
-
-	nodeID := reqNode.ID
-	network := reqNode.Network
-	password := reqNode.Password
-	macaddress := reqNode.MacAddress
-
-	var result models.NodeAuth
-
-	if nodeID == "" {
-		//TODO: Set Error  response
-		err = errors.New("missing node ID")
-		return nil, err
-	} else if password == "" {
-		err = errors.New("missing password")
-		return nil, err
-	} else {
-		//Search DB for node with ID. Ignore pending nodes (they should not be able to authenticate with API until approved).
-		collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
-		if err != nil {
-			return nil, err
-		}
-		var found = false
-		for _, value := range collection {
-			if err = json.Unmarshal([]byte(value), &result); err != nil {
-				continue // finish going through nodes
-			}
-			if result.ID == nodeID && result.Network == network {
-				found = true
-				break
-			}
-		}
-
-		if !found {
-			deletedNode, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, nodeID)
-			if err != nil {
-				err = errors.New("node not found")
-				return nil, err
-			}
-			if err = json.Unmarshal([]byte(deletedNode), &result); err != nil {
-				err = errors.New("node data corrupted")
-				return nil, err
-			}
-		}
-
-		//compare password from request to stored password in database
-		//might be able to have a common hash (certificates?) and compare those so that a password isn't passed in in plain text...
-		//TODO: Consider a way of hashing the password client side before sending, or using certificates
-		err = bcrypt.CompareHashAndPassword([]byte(result.Password), []byte(password))
-		if err != nil && result.Password != password {
-			return nil, err
-		} else {
-			//Create a new JWT for the node
-			tokenString, err := logic.CreateJWT(result.ID, macaddress, result.Network)
-
-			if err != nil {
-				return nil, err
-			}
-			if tokenString == "" {
-				err = errors.New("something went wrong, could not retrieve token")
-				return nil, err
-			}
-
-			response := &nodepb.Object{
-				Data: tokenString,
-				Type: nodepb.ACCESS_TOKEN,
-			}
-			return response, nil
-		}
-	}
-}

controllers/network.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/gorilla/mux"
 	"github.com/gravitl/netmaker/database"
@@ -431,3 +432,33 @@ func filterCommsNetwork(networks []models.Network) []models.Network {
 	}
 	return filterdNets
 }
+
+func getServerAddrs(node *models.Node) {
+	serverNodes := logic.GetServerNodes(serverctl.COMMS_NETID)
+	//pubIP, _ := servercfg.GetPublicIP()
+	if len(serverNodes) == 0 {
+		if err := serverctl.SyncServerNetwork(serverctl.COMMS_NETID); err != nil {
+			return
+		}
+	}
+
+	var serverAddrs = make([]models.ServerAddr, 0)
+
+	for _, node := range serverNodes {
+		if node.Address != "" {
+			serverAddrs = append(serverAddrs, models.ServerAddr{
+				IsLeader: logic.IsLeader(&node),
+				Address:  node.Address,
+			})
+		}
+	}
+
+	networkSettings, _ := logic.GetParentNetwork(node.Network)
+	// TODO consolidate functionality around files
+	networkSettings.NodesLastModified = time.Now().Unix()
+	networkSettings.DefaultServerAddrs = serverAddrs
+	if err := logic.SaveNetwork(&networkSettings); err != nil {
+		logger.Log(1, "unable to save network on serverAddr update", err.Error())
+	}
+	node.NetworkSettings.DefaultServerAddrs = networkSettings.DefaultServerAddrs
+}

controllers/node.go

@@ -746,3 +746,22 @@ func filterCommsNodes(nodes []models.Node) []models.Node {
 	}
 	return filterdNodes
 }
+
+func runForceServerUpdate(node *models.Node) {
+	go func() {
+		if err := mq.PublishPeerUpdate(node); err != nil {
+			logger.Log(1, "failed a peer update after creation of node", node.Name)
+		}
+
+		var currentServerNode, getErr = logic.GetNetworkServerLeader(node.Network)
+		if getErr == nil {
+			if err := logic.ServerUpdate(&currentServerNode, false); err != nil {
+				logger.Log(1, "server node:", currentServerNode.ID, "failed update")
+			}
+		}
+	}()
+}
+
+func isServer(node *models.Node) bool {
+	return node.IsServer == "yes"
+}

controllers/node_grpc.go

@@ -1,320 +0,0 @@
-package controller
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	nodepb "github.com/gravitl/netmaker/grpc"
-	"github.com/gravitl/netmaker/logger"
-	"github.com/gravitl/netmaker/logic"
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/mq"
-	"github.com/gravitl/netmaker/servercfg"
-	"github.com/gravitl/netmaker/serverctl"
-)
-
-// NodeServiceServer - represents the service server for gRPC
-type NodeServiceServer struct {
-	nodepb.UnimplementedNodeServiceServer
-}
-
-// NodeServiceServer.ReadNode - reads node and responds with gRPC
-func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-	var node, err = getNodeFromRequestData(req.Data)
-	if err != nil {
-		return nil, err
-	}
-
-	node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
-	if err != nil {
-		return nil, err
-	}
-	getServerAddrs(&node)
-
-	node.SetLastCheckIn()
-	// Cast to ReadNodeRes type
-	nodeData, errN := json.Marshal(&node)
-	if errN != nil {
-		return nil, err
-	}
-	logic.UpdateNode(&node, &node)
-	response := &nodepb.Object{
-		Data: string(nodeData),
-		Type: nodepb.NODE_TYPE,
-	}
-	return response, nil
-}
-
-// NodeServiceServer.CreateNode - creates a node and responds over gRPC
-func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-	var node = models.Node{}
-	var err error
-	data := req.GetData()
-	if err := json.Unmarshal([]byte(data), &node); err != nil {
-		return nil, err
-	}
-
-	validKey := logic.IsKeyValid(node.Network, node.AccessKey)
-	node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
-	if err != nil {
-		return nil, err
-	}
-	if !validKey {
-		if node.NetworkSettings.AllowManualSignUp == "yes" {
-			node.IsPending = "yes"
-		} else {
-			return nil, errors.New("invalid key, and network does not allow no-key signups")
-		}
-	}
-	getServerAddrs(&node)
-
-	key, keyErr := logic.RetrievePublicTrafficKey()
-	if keyErr != nil {
-		logger.Log(0, "error retrieving key: ", keyErr.Error())
-		return nil, keyErr
-	}
-
-	if key == nil {
-		logger.Log(0, "error: server traffic key is nil")
-		return nil, fmt.Errorf("error: server traffic key is nil")
-	}
-	if node.TrafficKeys.Mine == nil {
-		logger.Log(0, "error: node traffic key is nil")
-		return nil, fmt.Errorf("error: node traffic key is nil")
-	}
-
-	node.TrafficKeys = models.TrafficKeys{
-		Mine:   node.TrafficKeys.Mine,
-		Server: key,
-	}
-
-	err = logic.CreateNode(&node)
-	if err != nil {
-		return nil, err
-	}
-
-	nodeData, errN := json.Marshal(&node)
-	if errN != nil {
-		return nil, err
-	}
-
-	response := &nodepb.Object{
-		Data: string(nodeData),
-		Type: nodepb.NODE_TYPE,
-	}
-
-	runForceServerUpdate(&node)
-
-	go func(node *models.Node) {
-		if node.UDPHolePunch == "yes" {
-			var currentServerNode, getErr = logic.GetNetworkServerLeader(node.Network)
-			if getErr != nil {
-				return
-			}
-			for i := 0; i < 5; i++ {
-				if logic.HasPeerConnected(node) {
-					if logic.ShouldPublishPeerPorts(&currentServerNode) {
-						err = mq.PublishPeerUpdate(&currentServerNode)
-						if err != nil {
-							logger.Log(1, "error publishing port updates when node", node.Name, "joined")
-						}
-						break
-					}
-				}
-				time.Sleep(time.Second << 1) // allow time for client to startup
-			}
-		}
-	}(&node)
-
-	return response, nil
-}
-
-// NodeServiceServer.UpdateNode updates a node and responds over gRPC
-// DELETE ONE DAY - DEPRECATED
-func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-
-	var newnode models.Node
-	if err := json.Unmarshal([]byte(req.GetData()), &newnode); err != nil {
-		return nil, err
-	}
-
-	node, err := logic.GetNodeByID(newnode.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	if !servercfg.GetRce() {
-		newnode.PostDown = node.PostDown
-		newnode.PostUp = node.PostUp
-	}
-
-	err = logic.UpdateNode(&node, &newnode)
-	if err != nil {
-		return nil, err
-	}
-	newnode.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
-	if err != nil {
-		return nil, err
-	}
-	getServerAddrs(&newnode)
-
-	nodeData, errN := json.Marshal(&newnode)
-	if errN != nil {
-		return nil, err
-	}
-
-	return &nodepb.Object{
-		Data: string(nodeData),
-		Type: nodepb.NODE_TYPE,
-	}, nil
-}
-
-func getServerAddrs(node *models.Node) {
-	serverNodes := logic.GetServerNodes(serverctl.COMMS_NETID)
-	//pubIP, _ := servercfg.GetPublicIP()
-	if len(serverNodes) == 0 {
-		if err := serverctl.SyncServerNetwork(serverctl.COMMS_NETID); err != nil {
-			return
-		}
-	}
-
-	var serverAddrs = make([]models.ServerAddr, 0)
-
-	for _, node := range serverNodes {
-		if node.Address != "" {
-			serverAddrs = append(serverAddrs, models.ServerAddr{
-				IsLeader: logic.IsLeader(&node),
-				Address:  node.Address,
-			})
-		}
-	}
-
-	networkSettings, _ := logic.GetParentNetwork(node.Network)
-	// TODO consolidate functionality around files
-	networkSettings.NodesLastModified = time.Now().Unix()
-	networkSettings.DefaultServerAddrs = serverAddrs
-	if err := logic.SaveNetwork(&networkSettings); err != nil {
-		logger.Log(1, "unable to save network on serverAddr update", err.Error())
-	}
-	node.NetworkSettings.DefaultServerAddrs = networkSettings.DefaultServerAddrs
-}
-
-// NodeServiceServer.DeleteNode - deletes a node and responds over gRPC
-func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-
-	var node, err = getNodeFromRequestData(req.Data)
-	if err != nil {
-		return nil, err
-	}
-
-	err = logic.DeleteNodeByID(&node, true)
-	if err != nil {
-		return nil, err
-	}
-
-	runForceServerUpdate(&node)
-
-	return &nodepb.Object{
-		Data: "success",
-		Type: nodepb.STRING_TYPE,
-	}, nil
-}
-
-// NodeServiceServer.GetPeers - fetches peers over gRPC
-func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-
-	var node, err = getNodeFromRequestData(req.Data)
-	if err != nil {
-		return nil, err
-	}
-
-	peers, err := logic.GetPeersList(&node)
-	if err != nil {
-		if strings.Contains(err.Error(), logic.RELAY_NODE_ERR) {
-			peers, err = logic.PeerListUnRelay(node.ID, node.Network)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			return nil, err
-		}
-	}
-
-	peersData, err := json.Marshal(&peers)
-	logger.Log(3, node.Address, "checked in successfully")
-	return &nodepb.Object{
-		Data: string(peersData),
-		Type: nodepb.NODE_TYPE,
-	}, err
-}
-
-// NodeServiceServer.GetExtPeers - returns ext peers for a gateway node
-func (s *NodeServiceServer) GetExtPeers(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-
-	var node, err = getNodeFromRequestData(req.Data)
-	if err != nil {
-		return nil, err
-	}
-
-	peers, err := logic.GetExtPeersList(&node)
-	if err != nil {
-		return nil, err
-	}
-	var extPeers []models.Node
-	for i := 0; i < len(peers); i++ {
-		extPeers = append(extPeers, models.Node{
-			Address:             peers[i].Address,
-			Address6:            peers[i].Address6,
-			Endpoint:            peers[i].Endpoint,
-			PublicKey:           peers[i].PublicKey,
-			PersistentKeepalive: peers[i].KeepAlive,
-			ListenPort:          peers[i].ListenPort,
-			LocalAddress:        peers[i].LocalAddress,
-		})
-	}
-
-	extData, err := json.Marshal(&extPeers)
-	if err != nil {
-		return nil, err
-	}
-
-	return &nodepb.Object{
-		Data: string(extData),
-		Type: nodepb.EXT_PEER,
-	}, nil
-}
-
-// == private methods ==
-
-func getNodeFromRequestData(data string) (models.Node, error) {
-	var reqNode models.Node
-	var err error
-
-	if err = json.Unmarshal([]byte(data), &reqNode); err != nil {
-		return models.Node{}, err
-	}
-	return logic.GetNodeByID(reqNode.ID)
-}
-
-func isServer(node *models.Node) bool {
-	return node.IsServer == "yes"
-}
-
-func runForceServerUpdate(node *models.Node) {
-	go func() {
-		if err := mq.PublishPeerUpdate(node); err != nil {
-			logger.Log(1, "failed a peer update after creation of node", node.Name)
-		}
-
-		var currentServerNode, getErr = logic.GetNetworkServerLeader(node.Network)
-		if getErr == nil {
-			if err := logic.ServerUpdate(&currentServerNode, false); err != nil {
-				logger.Log(1, "server node:", currentServerNode.ID, "failed update")
-			}
-		}
-	}()
-}

grpc/node.pb.go

@@ -1,200 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.25.0-devel
-// 	protoc        v3.14.0
-// source: grpc/node.proto
-
-package nodepb
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-type Object struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Data     string `protobuf:"bytes,1,opt,name=Data,proto3" json:"Data,omitempty"`
-	Type     string `protobuf:"bytes,2,opt,name=Type,proto3" json:"Type,omitempty"`
-	Metadata string `protobuf:"bytes,3,opt,name=Metadata,proto3" json:"Metadata,omitempty"`
-}
-
-func (x *Object) Reset() {
-	*x = Object{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_grpc_node_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Object) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Object) ProtoMessage() {}
-
-func (x *Object) ProtoReflect() protoreflect.Message {
-	mi := &file_grpc_node_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Object.ProtoReflect.Descriptor instead.
-func (*Object) Descriptor() ([]byte, []int) {
-	return file_grpc_node_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *Object) GetData() string {
-	if x != nil {
-		return x.Data
-	}
-	return ""
-}
-
-func (x *Object) GetType() string {
-	if x != nil {
-		return x.Type
-	}
-	return ""
-}
-
-func (x *Object) GetMetadata() string {
-	if x != nil {
-		return x.Metadata
-	}
-	return ""
-}
-
-var File_grpc_node_proto protoreflect.FileDescriptor
-
-var file_grpc_node_proto_rawDesc = []byte{
-	0x0a, 0x0f, 0x67, 0x72, 0x70, 0x63, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x12, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0x4c, 0x0a, 0x06, 0x4f, 0x62, 0x6a, 0x65, 0x63,
-	0x74, 0x12, 0x12, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x4d, 0x65, 0x74,
-	0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x4d, 0x65, 0x74,
-	0x61, 0x64, 0x61, 0x74, 0x61, 0x32, 0xd2, 0x02, 0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65,
-	0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x05, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x12, 0x0c,
-	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x1a, 0x0c, 0x2e, 0x6e,
-	0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x28, 0x0a, 0x0a, 0x43, 0x72,
-	0x65, 0x61, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x0c, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e,
-	0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x1a, 0x0c, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62,
-	0x6a, 0x65, 0x63, 0x74, 0x12, 0x26, 0x0a, 0x08, 0x52, 0x65, 0x61, 0x64, 0x4e, 0x6f, 0x64, 0x65,
-	0x12, 0x0c, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x1a, 0x0c,
-	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x28, 0x0a, 0x0a,
-	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x0c, 0x2e, 0x6e, 0x6f, 0x64,
-	0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x1a, 0x0c, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e,
-	0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x28, 0x0a, 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
-	0x4e, 0x6f, 0x64, 0x65, 0x12, 0x0c, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65,
-	0x63, 0x74, 0x1a, 0x0c, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74,
-	0x12, 0x26, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x0c, 0x2e, 0x6e,
-	0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x1a, 0x0c, 0x2e, 0x6e, 0x6f, 0x64,
-	0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x29, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x45,
-	0x78, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x0c, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f,
-	0x62, 0x6a, 0x65, 0x63, 0x74, 0x1a, 0x0c, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a,
-	0x65, 0x63, 0x74, 0x12, 0x25, 0x0a, 0x07, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x49, 0x6e, 0x12, 0x0c,
-	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x1a, 0x0c, 0x2e, 0x6e,
-	0x6f, 0x64, 0x65, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x2f, 0x5a, 0x2d, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x6b,
-	0x6e, 0x6f, 0x77, 0x6e, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
-}
-
-var (
-	file_grpc_node_proto_rawDescOnce sync.Once
-	file_grpc_node_proto_rawDescData = file_grpc_node_proto_rawDesc
-)
-
-func file_grpc_node_proto_rawDescGZIP() []byte {
-	file_grpc_node_proto_rawDescOnce.Do(func() {
-		file_grpc_node_proto_rawDescData = protoimpl.X.CompressGZIP(file_grpc_node_proto_rawDescData)
-	})
-	return file_grpc_node_proto_rawDescData
-}
-
-var file_grpc_node_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_grpc_node_proto_goTypes = []interface{}{
-	(*Object)(nil), // 0: node.Object
-}
-var file_grpc_node_proto_depIdxs = []int32{
-	0, // 0: node.NodeService.Login:input_type -> node.Object
-	0, // 1: node.NodeService.CreateNode:input_type -> node.Object
-	0, // 2: node.NodeService.ReadNode:input_type -> node.Object
-	0, // 3: node.NodeService.UpdateNode:input_type -> node.Object
-	0, // 4: node.NodeService.DeleteNode:input_type -> node.Object
-	0, // 5: node.NodeService.GetPeers:input_type -> node.Object
-	0, // 6: node.NodeService.GetExtPeers:input_type -> node.Object
-	0, // 7: node.NodeService.CheckIn:input_type -> node.Object
-	0, // 8: node.NodeService.Login:output_type -> node.Object
-	0, // 9: node.NodeService.CreateNode:output_type -> node.Object
-	0, // 10: node.NodeService.ReadNode:output_type -> node.Object
-	0, // 11: node.NodeService.UpdateNode:output_type -> node.Object
-	0, // 12: node.NodeService.DeleteNode:output_type -> node.Object
-	0, // 13: node.NodeService.GetPeers:output_type -> node.Object
-	0, // 14: node.NodeService.GetExtPeers:output_type -> node.Object
-	0, // 15: node.NodeService.CheckIn:output_type -> node.Object
-	8, // [8:16] is the sub-list for method output_type
-	0, // [0:8] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_grpc_node_proto_init() }
-func file_grpc_node_proto_init() {
-	if File_grpc_node_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_grpc_node_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Object); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_grpc_node_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   1,
-			NumExtensions: 0,
-			NumServices:   1,
-		},
-		GoTypes:           file_grpc_node_proto_goTypes,
-		DependencyIndexes: file_grpc_node_proto_depIdxs,
-		MessageInfos:      file_grpc_node_proto_msgTypes,
-	}.Build()
-	File_grpc_node_proto = out.File
-	file_grpc_node_proto_rawDesc = nil
-	file_grpc_node_proto_goTypes = nil
-	file_grpc_node_proto_depIdxs = nil
-}

grpc/node.proto

@@ -1,20 +0,0 @@
-syntax = "proto3";
-package node;
-option go_package = "google.golang.org/protobuf/types/known/nodepb";
-
-service NodeService {
-    rpc Login(Object) returns (Object);
-    rpc CreateNode(Object) returns (Object);
-    rpc ReadNode(Object) returns (Object);
-    rpc UpdateNode(Object) returns (Object);
-    rpc DeleteNode(Object) returns (Object);
-    rpc GetPeers(Object) returns (Object);
-    rpc GetExtPeers(Object) returns (Object);
-    rpc CheckIn(Object) returns (Object);
-}
-
-message Object {  
-    string Data = 1;
-    string Type = 2;
-    string Metadata = 3;
-}

grpc/node_grpc.pb.go

@@ -1,353 +0,0 @@
-// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
-
-package nodepb
-
-import (
-	context "context"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-)
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
-
-// NodeServiceClient is the client API for NodeService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
-type NodeServiceClient interface {
-	Login(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error)
-	CreateNode(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error)
-	ReadNode(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error)
-	UpdateNode(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error)
-	DeleteNode(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error)
-	GetPeers(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error)
-	GetExtPeers(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error)
-	CheckIn(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error)
-}
-
-type nodeServiceClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewNodeServiceClient(cc grpc.ClientConnInterface) NodeServiceClient {
-	return &nodeServiceClient{cc}
-}
-
-func (c *nodeServiceClient) Login(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error) {
-	out := new(Object)
-	err := c.cc.Invoke(ctx, "/node.NodeService/Login", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *nodeServiceClient) CreateNode(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error) {
-	out := new(Object)
-	err := c.cc.Invoke(ctx, "/node.NodeService/CreateNode", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *nodeServiceClient) ReadNode(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error) {
-	out := new(Object)
-	err := c.cc.Invoke(ctx, "/node.NodeService/ReadNode", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *nodeServiceClient) UpdateNode(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error) {
-	out := new(Object)
-	err := c.cc.Invoke(ctx, "/node.NodeService/UpdateNode", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *nodeServiceClient) DeleteNode(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error) {
-	out := new(Object)
-	err := c.cc.Invoke(ctx, "/node.NodeService/DeleteNode", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *nodeServiceClient) GetPeers(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error) {
-	out := new(Object)
-	err := c.cc.Invoke(ctx, "/node.NodeService/GetPeers", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *nodeServiceClient) GetExtPeers(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error) {
-	out := new(Object)
-	err := c.cc.Invoke(ctx, "/node.NodeService/GetExtPeers", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *nodeServiceClient) CheckIn(ctx context.Context, in *Object, opts ...grpc.CallOption) (*Object, error) {
-	out := new(Object)
-	err := c.cc.Invoke(ctx, "/node.NodeService/CheckIn", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// NodeServiceServer is the server API for NodeService service.
-// All implementations must embed UnimplementedNodeServiceServer
-// for forward compatibility
-type NodeServiceServer interface {
-	Login(context.Context, *Object) (*Object, error)
-	CreateNode(context.Context, *Object) (*Object, error)
-	ReadNode(context.Context, *Object) (*Object, error)
-	UpdateNode(context.Context, *Object) (*Object, error)
-	DeleteNode(context.Context, *Object) (*Object, error)
-	GetPeers(context.Context, *Object) (*Object, error)
-	GetExtPeers(context.Context, *Object) (*Object, error)
-	CheckIn(context.Context, *Object) (*Object, error)
-	mustEmbedUnimplementedNodeServiceServer()
-}
-
-// UnimplementedNodeServiceServer must be embedded to have forward compatible implementations.
-type UnimplementedNodeServiceServer struct {
-}
-
-func (UnimplementedNodeServiceServer) Login(context.Context, *Object) (*Object, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Login not implemented")
-}
-func (UnimplementedNodeServiceServer) CreateNode(context.Context, *Object) (*Object, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CreateNode not implemented")
-}
-func (UnimplementedNodeServiceServer) ReadNode(context.Context, *Object) (*Object, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ReadNode not implemented")
-}
-func (UnimplementedNodeServiceServer) UpdateNode(context.Context, *Object) (*Object, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method UpdateNode not implemented")
-}
-func (UnimplementedNodeServiceServer) DeleteNode(context.Context, *Object) (*Object, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method DeleteNode not implemented")
-}
-func (UnimplementedNodeServiceServer) GetPeers(context.Context, *Object) (*Object, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetPeers not implemented")
-}
-func (UnimplementedNodeServiceServer) GetExtPeers(context.Context, *Object) (*Object, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetExtPeers not implemented")
-}
-func (UnimplementedNodeServiceServer) CheckIn(context.Context, *Object) (*Object, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CheckIn not implemented")
-}
-func (UnimplementedNodeServiceServer) mustEmbedUnimplementedNodeServiceServer() {}
-
-// UnsafeNodeServiceServer may be embedded to opt out of forward compatibility for this service.
-// Use of this interface is not recommended, as added methods to NodeServiceServer will
-// result in compilation errors.
-type UnsafeNodeServiceServer interface {
-	mustEmbedUnimplementedNodeServiceServer()
-}
-
-func RegisterNodeServiceServer(s grpc.ServiceRegistrar, srv NodeServiceServer) {
-	s.RegisterService(&NodeService_ServiceDesc, srv)
-}
-
-func _NodeService_Login_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Object)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).Login(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/node.NodeService/Login",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).Login(ctx, req.(*Object))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _NodeService_CreateNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Object)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).CreateNode(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/node.NodeService/CreateNode",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).CreateNode(ctx, req.(*Object))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _NodeService_ReadNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Object)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).ReadNode(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/node.NodeService/ReadNode",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).ReadNode(ctx, req.(*Object))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _NodeService_UpdateNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Object)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).UpdateNode(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/node.NodeService/UpdateNode",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).UpdateNode(ctx, req.(*Object))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _NodeService_DeleteNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Object)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).DeleteNode(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/node.NodeService/DeleteNode",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).DeleteNode(ctx, req.(*Object))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _NodeService_GetPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Object)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).GetPeers(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/node.NodeService/GetPeers",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).GetPeers(ctx, req.(*Object))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _NodeService_GetExtPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Object)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).GetExtPeers(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/node.NodeService/GetExtPeers",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).GetExtPeers(ctx, req.(*Object))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _NodeService_CheckIn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Object)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).CheckIn(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/node.NodeService/CheckIn",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).CheckIn(ctx, req.(*Object))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-// NodeService_ServiceDesc is the grpc.ServiceDesc for NodeService service.
-// It's only intended for direct use with grpc.RegisterService,
-// and not to be introspected or modified (even as a copy)
-var NodeService_ServiceDesc = grpc.ServiceDesc{
-	ServiceName: "node.NodeService",
-	HandlerType: (*NodeServiceServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "Login",
-			Handler:    _NodeService_Login_Handler,
-		},
-		{
-			MethodName: "CreateNode",
-			Handler:    _NodeService_CreateNode_Handler,
-		},
-		{
-			MethodName: "ReadNode",
-			Handler:    _NodeService_ReadNode_Handler,
-		},
-		{
-			MethodName: "UpdateNode",
-			Handler:    _NodeService_UpdateNode_Handler,
-		},
-		{
-			MethodName: "DeleteNode",
-			Handler:    _NodeService_DeleteNode_Handler,
-		},
-		{
-			MethodName: "GetPeers",
-			Handler:    _NodeService_GetPeers_Handler,
-		},
-		{
-			MethodName: "GetExtPeers",
-			Handler:    _NodeService_GetExtPeers_Handler,
-		},
-		{
-			MethodName: "CheckIn",
-			Handler:    _NodeService_CheckIn_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "grpc/node.proto",
-}

grpc/types.go

@@ -1,6 +0,0 @@
-package nodepb
-
-const STRING_TYPE = "string"
-const NODE_TYPE = "node"
-const EXT_PEER = "extpeer"
-const ACCESS_TOKEN = "accesstoken"

main.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"flag"
 	"fmt"
-	"net"
 	"os"
 	"os/signal"
 	"runtime/debug"
@@ -21,7 +20,6 @@ import (
 	controller "github.com/gravitl/netmaker/controllers"
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/functions"
-	nodepb "github.com/gravitl/netmaker/grpc"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
@@ -30,7 +28,6 @@ import (
 	"github.com/gravitl/netmaker/servercfg"
 	"github.com/gravitl/netmaker/serverctl"
 	"github.com/gravitl/netmaker/tls"
-	"google.golang.org/grpc"
 )
 
 var version = "dev"
@@ -128,16 +125,16 @@ func initialize() { // Client Mode Prereq Check
 func startControllers() {
 	var waitnetwork sync.WaitGroup
 	//Run Agent Server
-	if servercfg.IsAgentBackend() {
-		if !(servercfg.DisableRemoteIPCheck()) && servercfg.GetGRPCHost() == "127.0.0.1" {
-			err := servercfg.SetHost()
-			if err != nil {
-				logger.FatalLog("Unable to Set host. Exiting...", err.Error())
-			}
-		}
-		waitnetwork.Add(1)
-		go runGRPC(&waitnetwork)
-	}
+	//	if servercfg.IsAgentBackend() {
+	//		if !(servercfg.DisableRemoteIPCheck()) && servercfg.GetGRPCHost() == "127.0.0.1" {
+	//			err := servercfg.SetHost()
+	//			if err != nil {
+	//				logger.FatalLog("Unable to Set host. Exiting...", err.Error())
+	//			}
+	//		}
+	//		waitnetwork.Add(1)
+	//		go runGRPC(&waitnetwork)
+	//	}
 
 	if servercfg.IsDNSMode() {
 		err := logic.SetDNS()
@@ -170,51 +167,51 @@ func startControllers() {
 	waitnetwork.Wait()
 }
 
-func runGRPC(wg *sync.WaitGroup) {
+// func runGRPC(wg *sync.WaitGroup) {
 
-	defer wg.Done()
+// 	defer wg.Done()
 
-	grpcport := servercfg.GetGRPCPort()
+// 	grpcport := servercfg.GetGRPCPort()
 
-	listener, err := net.Listen("tcp", ":"+grpcport)
-	// Handle errors if any
-	if err != nil {
-		logger.FatalLog("[netmaker] Unable to listen on port", grpcport, ": error:", err.Error())
-	}
+// 	listener, err := net.Listen("tcp", ":"+grpcport)
+// 	// Handle errors if any
+// 	if err != nil {
+// 		logger.FatalLog("[netmaker] Unable to listen on port", grpcport, ": error:", err.Error())
+// 	}
 
-	s := grpc.NewServer(
-		authServerUnaryInterceptor(),
-	)
-	// Create NodeService type
-	srv := &controller.NodeServiceServer{}
+// 	s := grpc.NewServer(
+// 		authServerUnaryInterceptor(),
+// 	)
+// 	// Create NodeService type
+// 	srv := &controller.NodeServiceServer{}
 
-	// Register the service with the server
-	nodepb.RegisterNodeServiceServer(s, srv)
+// 	// Register the service with the server
+// 	nodepb.RegisterNodeServiceServer(s, srv)
 
-	// Start the server in a child routine
-	go func() {
-		if err := s.Serve(listener); err != nil {
-			logger.FatalLog("Failed to serve:", err.Error())
-		}
-	}()
-	logger.Log(0, "Agent Server successfully started on port ", grpcport, "(gRPC)")
-
-	// Relay os.Interrupt to our channel (os.Interrupt = CTRL+C)
-	// Ignore other incoming signals
-	ctx, stop := signal.NotifyContext(context.TODO(), os.Interrupt)
-	defer stop()
-
-	// Block main routine until a signal is received
-	// As long as user doesn't press CTRL+C a message is not passed and our main routine keeps running
-	<-ctx.Done()
-
-	// After receiving CTRL+C Properly stop the server
-	logger.Log(0, "Stopping the Agent server...")
-	s.GracefulStop()
-	listener.Close()
-	logger.Log(0, "Agent server closed..")
-	logger.Log(0, "Closed DB connection.")
-}
+// 	// Start the server in a child routine
+// 	go func() {
+// 		if err := s.Serve(listener); err != nil {
+// 			logger.FatalLog("Failed to serve:", err.Error())
+// 		}
+// 	}()
+// 	logger.Log(0, "Agent Server successfully started on port ", grpcport, "(gRPC)")
+
+// 	// Relay os.Interrupt to our channel (os.Interrupt = CTRL+C)
+// 	// Ignore other incoming signals
+// 	ctx, stop := signal.NotifyContext(context.TODO(), os.Interrupt)
+// 	defer stop()
+
+// 	// Block main routine until a signal is received
+// 	// As long as user doesn't press CTRL+C a message is not passed and our main routine keeps running
+// 	<-ctx.Done()
+
+// 	// After receiving CTRL+C Properly stop the server
+// 	logger.Log(0, "Stopping the Agent server...")
+// 	s.GracefulStop()
+// 	listener.Close()
+// 	logger.Log(0, "Agent server closed..")
+// 	logger.Log(0, "Closed DB connection.")
+// }
 
 // Should we be using a context vice a waitgroup????????????
 func runMessageQueue(wg *sync.WaitGroup) {
@@ -231,9 +228,9 @@ func runMessageQueue(wg *sync.WaitGroup) {
 	client.Disconnect(250)
 }
 
-func authServerUnaryInterceptor() grpc.ServerOption {
-	return grpc.UnaryInterceptor(controller.AuthServerUnaryInterceptor)
-}
+//func authServerUnaryInterceptor() grpc.ServerOption {
+//	return grpc.UnaryInterceptor(controller.AuthServerUnaryInterceptor)
+//}
 
 func setGarbageCollection() {
 	_, gcset := os.LookupEnv("GOGC")

netclient/auth/auth.go

@@ -1,84 +1,73 @@
 package auth
 
 import (
-	"encoding/json"
-	"fmt"
 	"os"
 
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/netclient/config"
 	"github.com/gravitl/netmaker/netclient/ncutils"
-
 	//    "os"
-	"context"
-
-	nodepb "github.com/gravitl/netmaker/grpc"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
 )
 
 // SetJWT func will used to create the JWT while signing in and signing out
-func SetJWT(client nodepb.NodeServiceClient, network string) (context.Context, error) {
-	home := ncutils.GetNetclientPathSpecific()
-	tokentext, err := os.ReadFile(home + "nettoken-" + network)
-	if err != nil {
-		err = AutoLogin(client, network)
-		if err != nil {
-			return nil, status.Errorf(codes.Unauthenticated, fmt.Sprintf("Something went wrong with Auto Login: %v", err))
-		}
-		tokentext, err = ncutils.GetFileWithRetry(home+"nettoken-"+network, 1)
-		if err != nil {
-			return nil, status.Errorf(codes.Unauthenticated, fmt.Sprintf("Something went wrong: %v", err))
-		}
-	}
-	token := string(tokentext)
-
-	// Anything linked to this variable will transmit request headers.
-	md := metadata.New(map[string]string{"authorization": token})
-	ctx := context.Background()
-	ctx = metadata.NewOutgoingContext(ctx, md)
-	return ctx, nil
-}
+//func SetJWT(client nodepb.NodeServiceClient, network string) (context.Context, error) {
+//	home := ncutils.GetNetclientPathSpecific()
+//	tokentext, err := os.ReadFile(home + "nettoken-" + network)
+//	if err != nil {
+//		err = AutoLogin(client, network)
+//		if err != nil {
+//			return nil, status.Errorf(codes.Unauthenticated, fmt.Sprintf("Something went wrong with Auto Login: %v", err))
+//		}
+//		tokentext, err = ncutils.GetFileWithRetry(home+"nettoken-"+network, 1)
+//		if err != nil {
+//			return nil, status.Errorf(codes.Unauthenticated, fmt.Sprintf("Something went wrong: %v", err))
+//		}
+//	}
+//	token := string(tokentext)
+//
+//	// Anything linked to this variable will transmit request headers.
+//	md := metadata.New(map[string]string{"authorization": token})
+//	ctx := context.Background()
+//	ctx = metadata.NewOutgoingContext(ctx, md)
+//	return ctx, nil
+//}
 
 // AutoLogin - auto logins whenever client needs to request from server
-func AutoLogin(client nodepb.NodeServiceClient, network string) error {
-	home := ncutils.GetNetclientPathSpecific()
-	cfg, err := config.ReadConfig(network)
-	if err != nil {
-		return err
-	}
-	pass, err := RetrieveSecret(network)
-	if err != nil {
-		return err
-	}
-	node := models.Node{
-		Password:   pass,
-		MacAddress: cfg.Node.MacAddress,
-		ID:         cfg.Node.ID,
-		Network:    network,
-	}
-	data, err := json.Marshal(&node)
-	if err != nil {
-		return nil
-	}
-
-	login := &nodepb.Object{
-		Data: string(data),
-		Type: nodepb.NODE_TYPE,
-	}
-	// RPC call
-	res, err := client.Login(context.TODO(), login)
-	if err != nil {
-		return err
-	}
-	tokenstring := []byte(res.Data)
-	err = os.WriteFile(home+"nettoken-"+network, tokenstring, 0600)
-	if err != nil {
-		return err
-	}
-	return err
-}
+//func AutoLogin(client nodepb.NodeServiceClient, network string) error {
+//	home := ncutils.GetNetclientPathSpecific()
+//	cfg, err := config.ReadConfig(network)
+//	if err != nil {
+//		return err
+//	}
+//	pass, err := RetrieveSecret(network)
+//	if err != nil {
+//		return err
+//	}
+//	node := models.Node{
+//		Password:   pass,
+//		MacAddress: cfg.Node.MacAddress,
+//		ID:         cfg.Node.ID,
+//		Network:    network,
+//	}
+//	data, err := json.Marshal(&node)
+//	if err != nil {
+//		return nil
+//	}
+//
+//	login := &nodepb.Object{
+//		Data: string(data),
+//		Type: nodepb.NODE_TYPE,
+//	}
+//	// RPC call
+//	res, err := client.Login(context.TODO(), login)
+//	if err != nil {
+//		return err
+//	}
+//	tokenstring := []byte(res.Data)
+//	err = os.WriteFile(home+"nettoken-"+network, tokenstring, 0600)
+//	if err != nil {
+//		return err
+//	}
+//	return err
+//}
 
 // StoreSecret - stores auth secret locally
 func StoreSecret(key string, network string) error {

netclient/functions/list.go

@@ -4,14 +4,9 @@ import (
 	"encoding/json"
 	"fmt"
 
-	nodepb "github.com/gravitl/netmaker/grpc"
 	"github.com/gravitl/netmaker/logger"
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/netclient/auth"
 	"github.com/gravitl/netmaker/netclient/config"
 	"github.com/gravitl/netmaker/netclient/ncutils"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
 )
 
 // Peer - the peer struct for list
@@ -67,7 +62,8 @@ func getNetwork(network string) (Network, error) {
 	if err != nil {
 		return Network{}, fmt.Errorf("reading configuration for network %v: %w", network, err)
 	}
-	peers, err := getPeers(network)
+	//peers, err := getPeers(network)
+	peers := []Peer{}
 	if err != nil {
 		return Network{}, fmt.Errorf("listing peers for network %v: %w", network, err)
 	}
@@ -85,55 +81,55 @@ func getNetwork(network string) (Network, error) {
 	}, nil
 }
 
-func getPeers(network string) ([]Peer, error) {
-	cfg, err := config.ReadConfig(network)
-	if err != nil {
-		return []Peer{}, err
-	}
-	nodecfg := cfg.Node
-	var nodes []models.Node
-
-	var wcclient nodepb.NodeServiceClient
-	conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-		ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
-
-	if err != nil {
-		return []Peer{}, fmt.Errorf("connecting to %v: %w", cfg.Server.GRPCAddress, err)
-	}
-	defer conn.Close()
-	// Instantiate the BlogServiceClient with our client connection to the server
-	wcclient = nodepb.NewNodeServiceClient(conn)
-
-	nodeData, err := json.Marshal(&nodecfg)
-	if err != nil {
-		return []Peer{}, fmt.Errorf("could not parse config node on network %s : %w", network, err)
-	}
-
-	req := &nodepb.Object{
-		Data: string(nodeData),
-		Type: nodepb.NODE_TYPE,
-	}
-
-	ctx, err := auth.SetJWT(wcclient, network)
-	if err != nil {
-		return []Peer{}, fmt.Errorf("authenticating: %w", err)
-	}
-	var header metadata.MD
-
-	response, err := wcclient.GetPeers(ctx, req, grpc.Header(&header))
-	if err != nil {
-		return []Peer{}, fmt.Errorf("retrieving peers: %w", err)
-	}
-	if err := json.Unmarshal([]byte(response.GetData()), &nodes); err != nil {
-		return []Peer{}, fmt.Errorf("unmarshaling data for peers: %w", err)
-	}
-
-	peers := []Peer{}
-	for _, node := range nodes {
-		if node.Name != cfg.Node.Name {
-			peers = append(peers, Peer{Name: fmt.Sprintf("%v.%v", node.Name, network), PrivateIPv4: node.Address, PrivateIPv6: node.Address6})
-		}
-	}
-
-	return peers, nil
-}
+// func getPeers(network string) ([]Peer, error) {
+// cfg, err := config.ReadConfig(network)
+// if err != nil {
+// return []Peer{}, err
+// }
+// nodecfg := cfg.Node
+// var nodes []models.Node
+//
+// var wcclient nodepb.NodeServiceClient
+// conn, err := grpc.Dial(cfg.Server.GRPCAddress,
+// ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
+//
+// if err != nil {
+// return []Peer{}, fmt.Errorf("connecting to %v: %w", cfg.Server.GRPCAddress, err)
+// }
+// defer conn.Close()
+//	Instantiate the BlogServiceClient with our client connection to the server
+// wcclient = nodepb.NewNodeServiceClient(conn)
+//
+// nodeData, err := json.Marshal(&nodecfg)
+// if err != nil {
+// return []Peer{}, fmt.Errorf("could not parse config node on network %s : %w", network, err)
+// }
+//
+// req := &nodepb.Object{
+// Data: string(nodeData),
+// Type: nodepb.NODE_TYPE,
+// }
+//
+// ctx, err := auth.SetJWT(wcclient, network)
+// if err != nil {
+// return []Peer{}, fmt.Errorf("authenticating: %w", err)
+// }
+// var header metadata.MD
+//
+// response, err := wcclient.GetPeers(ctx, req, grpc.Header(&header))
+// if err != nil {
+// return []Peer{}, fmt.Errorf("retrieving peers: %w", err)
+// }
+// if err := json.Unmarshal([]byte(response.GetData()), &nodes); err != nil {
+// return []Peer{}, fmt.Errorf("unmarshaling data for peers: %w", err)
+// }
+//
+// peers := []Peer{}
+// for _, node := range nodes {
+// if node.Name != cfg.Node.Name {
+// peers = append(peers, Peer{Name: fmt.Sprintf("%v.%v", node.Name, network), PrivateIPv4: node.Address, PrivateIPv6: node.Address6})
+// }
+// }
+//
+// return peers, nil
+// }

netclient/server/grpc.go

@@ -1,346 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"log"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-
-	nodepb "github.com/gravitl/netmaker/grpc"
-	"github.com/gravitl/netmaker/logger"
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/netclient/auth"
-	"github.com/gravitl/netmaker/netclient/config"
-	"github.com/gravitl/netmaker/netclient/ncutils"
-	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
-)
-
-// RELAY_KEEPALIVE_MARKER - sets the relay keepalive marker
-const RELAY_KEEPALIVE_MARKER = "20007ms"
-
-func getGrpcClient(cfg *config.ClientConfig) (nodepb.NodeServiceClient, error) {
-	var wcclient nodepb.NodeServiceClient
-	// == GRPC SETUP ==
-	conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-		ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
-
-	if err != nil {
-		return nil, err
-	}
-	defer conn.Close()
-	wcclient = nodepb.NewNodeServiceClient(conn)
-	return wcclient, nil
-}
-
-// CheckIn - checkin for node on a network
-func CheckIn(network string) (*models.Node, error) {
-	cfg, err := config.ReadConfig(network)
-	if err != nil {
-		return nil, err
-	}
-	node := cfg.Node
-	if cfg.Node.IsServer != "yes" {
-		wcclient, err := getGrpcClient(cfg)
-		if err != nil {
-			return nil, err
-		}
-		// == run client action ==
-		var header metadata.MD
-		ctx, err := auth.SetJWT(wcclient, network)
-		if err != nil {
-			return nil, err
-		}
-		nodeData, err := json.Marshal(&node)
-		if err != nil {
-			return nil, err
-		}
-		response, err := wcclient.ReadNode(
-			ctx,
-			&nodepb.Object{
-				Data: string(nodeData),
-				Type: nodepb.NODE_TYPE,
-			},
-			grpc.Header(&header),
-		)
-		if err != nil {
-			log.Printf("Encountered error checking in node: %v", err)
-		}
-		if err = json.Unmarshal([]byte(response.GetData()), &node); err != nil {
-			return nil, err
-		}
-	}
-	return &node, err
-}
-
-// GetPeers - gets the peers for a node
-func GetPeers(macaddress string, network string, server string, dualstack bool, isIngressGateway bool, isServer bool) ([]wgtypes.PeerConfig, bool, []string, error) {
-	hasGateway := false
-	var err error
-	var gateways []string
-	var peers []wgtypes.PeerConfig
-	var nodecfg models.Node
-	var nodes []models.Node // fill above fields from server or client
-
-	if !isServer { // set peers client side
-		cfg, err := config.ReadConfig(network)
-		if err != nil {
-			log.Fatalf("Issue retrieving config for network: "+network+". Please investigate: %v", err)
-		}
-		nodecfg = cfg.Node
-		var wcclient nodepb.NodeServiceClient
-		conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-			ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
-
-		if err != nil {
-			log.Fatalf("Unable to establish client connection to localhost:50051: %v", err)
-		}
-		defer conn.Close()
-		// Instantiate the BlogServiceClient with our client connection to the server
-		wcclient = nodepb.NewNodeServiceClient(conn)
-
-		nodeData, err := json.Marshal(&nodecfg)
-		if err != nil {
-			logger.Log(1, "could not parse node data from config during peer fetch for network ", network)
-			return peers, hasGateway, gateways, err
-		}
-
-		req := &nodepb.Object{
-			Data: string(nodeData),
-			Type: nodepb.NODE_TYPE,
-		}
-
-		ctx, err := auth.SetJWT(wcclient, network)
-		if err != nil {
-			log.Println("Failed to authenticate.")
-			return peers, hasGateway, gateways, err
-		}
-		var header metadata.MD
-
-		response, err := wcclient.GetPeers(ctx, req, grpc.Header(&header))
-		if err != nil {
-			log.Println("Error retrieving peers")
-			log.Println(err)
-			return nil, hasGateway, gateways, err
-		}
-		if err := json.Unmarshal([]byte(response.GetData()), &nodes); err != nil {
-			log.Println("Error unmarshaling data for peers")
-			return nil, hasGateway, gateways, err
-		}
-	}
-
-	keepalive := nodecfg.PersistentKeepalive
-	keepalivedur, _ := time.ParseDuration(strconv.FormatInt(int64(keepalive), 10) + "s")
-	keepaliveserver, err := time.ParseDuration(strconv.FormatInt(int64(5), 10) + "s")
-	if err != nil {
-		log.Fatalf("Issue with format of keepalive value. Please update netconfig: %v", err)
-	}
-
-	for _, node := range nodes {
-		pubkey, err := wgtypes.ParseKey(node.PublicKey)
-		if err != nil {
-			log.Println("error parsing key")
-			return peers, hasGateway, gateways, err
-		}
-
-		if nodecfg.PublicKey == node.PublicKey {
-			continue
-		}
-		if nodecfg.Endpoint == node.Endpoint {
-			if nodecfg.LocalAddress != node.LocalAddress && node.LocalAddress != "" {
-				node.Endpoint = node.LocalAddress
-			} else {
-				continue
-			}
-		}
-
-		var peer wgtypes.PeerConfig
-		var peeraddr = net.IPNet{
-			IP:   net.ParseIP(node.Address),
-			Mask: net.CIDRMask(32, 32),
-		}
-		var allowedips []net.IPNet
-		allowedips = append(allowedips, peeraddr)
-		// handle manually set peers
-		for _, allowedIp := range node.AllowedIPs {
-			if _, ipnet, err := net.ParseCIDR(allowedIp); err == nil {
-				nodeEndpointArr := strings.Split(node.Endpoint, ":")
-				if !ipnet.Contains(net.IP(nodeEndpointArr[0])) && ipnet.IP.String() != node.Address { // don't need to add an allowed ip that already exists..
-					allowedips = append(allowedips, *ipnet)
-				}
-			} else if appendip := net.ParseIP(allowedIp); appendip != nil && allowedIp != node.Address {
-				ipnet := net.IPNet{
-					IP:   net.ParseIP(allowedIp),
-					Mask: net.CIDRMask(32, 32),
-				}
-				allowedips = append(allowedips, ipnet)
-			}
-		}
-		// handle egress gateway peers
-		if node.IsEgressGateway == "yes" {
-			hasGateway = true
-			ranges := node.EgressGatewayRanges
-			for _, iprange := range ranges { // go through each cidr for egress gateway
-				_, ipnet, err := net.ParseCIDR(iprange) // confirming it's valid cidr
-				if err != nil {
-					logger.Log(1, "could not parse gateway IP range. Not adding ", iprange)
-					continue // if can't parse CIDR
-				}
-				nodeEndpointArr := strings.Split(node.Endpoint, ":") // getting the public ip of node
-				if ipnet.Contains(net.ParseIP(nodeEndpointArr[0])) { // ensuring egress gateway range does not contain public ip of node
-					logger.Log(2, "egress IP range of ", iprange, " overlaps with ", node.Endpoint, ", omitting")
-					continue // skip adding egress range if overlaps with node's ip
-				}
-				if ipnet.Contains(net.ParseIP(nodecfg.LocalAddress)) { // ensuring egress gateway range does not contain public ip of node
-					logger.Log(2, "egress IP range of ", iprange, " overlaps with ", nodecfg.LocalAddress, ", omitting")
-					continue // skip adding egress range if overlaps with node's local ip
-				}
-				gateways = append(gateways, iprange)
-				if err != nil {
-					log.Println("ERROR ENCOUNTERED SETTING GATEWAY")
-				} else {
-					allowedips = append(allowedips, *ipnet)
-				}
-			}
-		}
-		if node.Address6 != "" && dualstack {
-			var addr6 = net.IPNet{
-				IP:   net.ParseIP(node.Address6),
-				Mask: net.CIDRMask(128, 128),
-			}
-			allowedips = append(allowedips, addr6)
-		}
-		if nodecfg.IsServer == "yes" && !(node.IsServer == "yes") {
-			peer = wgtypes.PeerConfig{
-				PublicKey:                   pubkey,
-				PersistentKeepaliveInterval: &keepaliveserver,
-				ReplaceAllowedIPs:           true,
-				AllowedIPs:                  allowedips,
-			}
-		} else if keepalive != 0 {
-			peer = wgtypes.PeerConfig{
-				PublicKey:                   pubkey,
-				PersistentKeepaliveInterval: &keepalivedur,
-				Endpoint: &net.UDPAddr{
-					IP:   net.ParseIP(node.Endpoint),
-					Port: int(node.ListenPort),
-				},
-				ReplaceAllowedIPs: true,
-				AllowedIPs:        allowedips,
-			}
-		} else {
-			peer = wgtypes.PeerConfig{
-				PublicKey: pubkey,
-				Endpoint: &net.UDPAddr{
-					IP:   net.ParseIP(node.Endpoint),
-					Port: int(node.ListenPort),
-				},
-				ReplaceAllowedIPs: true,
-				AllowedIPs:        allowedips,
-			}
-		}
-		peers = append(peers, peer)
-	}
-	if isIngressGateway {
-		extPeers, err := GetExtPeers(macaddress, network, server, dualstack)
-		if err == nil {
-			peers = append(peers, extPeers...)
-		} else {
-			log.Println("ERROR RETRIEVING EXTERNAL PEERS", err)
-		}
-	}
-	return peers, hasGateway, gateways, err
-}
-
-// GetExtPeers - gets the extpeers for a client
-func GetExtPeers(macaddress string, network string, server string, dualstack bool) ([]wgtypes.PeerConfig, error) {
-	var peers []wgtypes.PeerConfig
-	var nodecfg models.Node
-	var extPeers []models.Node
-	var err error
-	// fill above fields from either client or server
-
-	if nodecfg.IsServer != "yes" { // fill extPeers with client side logic
-		var cfg *config.ClientConfig
-		cfg, err = config.ReadConfig(network)
-		if err != nil {
-			log.Fatalf("Issue retrieving config for network: "+network+". Please investigate: %v", err)
-		}
-		nodecfg = cfg.Node
-		var wcclient nodepb.NodeServiceClient
-
-		conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-			ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
-		if err != nil {
-			log.Fatalf("Unable to establish client connection to localhost:50051: %v", err)
-		}
-		defer conn.Close()
-		// Instantiate the BlogServiceClient with our client connection to the server
-		wcclient = nodepb.NewNodeServiceClient(conn)
-
-		nodeData, err := json.Marshal(&nodecfg)
-		if err != nil {
-			logger.Log(1, "could not parse node data from config during peer fetch for network ", network)
-			return peers, err
-		}
-
-		req := &nodepb.Object{
-			Data: string(nodeData),
-			Type: nodepb.NODE_TYPE,
-		}
-
-		ctx, err := auth.SetJWT(wcclient, network)
-		if err != nil {
-			log.Println("Failed to authenticate.")
-			return peers, err
-		}
-		var header metadata.MD
-
-		responseObject, err := wcclient.GetExtPeers(ctx, req, grpc.Header(&header))
-		if err != nil {
-			log.Println("Error retrieving peers")
-			log.Println(err)
-			return nil, err
-		}
-		if err = json.Unmarshal([]byte(responseObject.Data), &extPeers); err != nil {
-			return nil, err
-		}
-	}
-	for _, extPeer := range extPeers {
-		pubkey, err := wgtypes.ParseKey(extPeer.PublicKey)
-		if err != nil {
-			log.Println("error parsing key")
-			return peers, err
-		}
-
-		if nodecfg.PublicKey == extPeer.PublicKey {
-			continue
-		}
-
-		var peer wgtypes.PeerConfig
-		var peeraddr = net.IPNet{
-			IP:   net.ParseIP(extPeer.Address),
-			Mask: net.CIDRMask(32, 32),
-		}
-		var allowedips []net.IPNet
-		allowedips = append(allowedips, peeraddr)
-
-		if extPeer.Address6 != "" && dualstack {
-			var addr6 = net.IPNet{
-				IP:   net.ParseIP(extPeer.Address6),
-				Mask: net.CIDRMask(128, 128),
-			}
-			allowedips = append(allowedips, addr6)
-		}
-		peer = wgtypes.PeerConfig{
-			PublicKey:         pubkey,
-			ReplaceAllowedIPs: true,
-			AllowedIPs:        allowedips,
-		}
-		peers = append(peers, peer)
-	}
-	return peers, err
-}

netclient/wireguard/common.go

@@ -14,7 +14,6 @@ import (
 	"github.com/gravitl/netmaker/netclient/config"
 	"github.com/gravitl/netmaker/netclient/local"
 	"github.com/gravitl/netmaker/netclient/ncutils"
-	"github.com/gravitl/netmaker/netclient/server"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 	"gopkg.in/ini.v1"
@@ -230,10 +229,10 @@ func SetWGConfig(network string, peerupdate bool) error {
 	servercfg := cfg.Server
 	nodecfg := cfg.Node
 
-	peers, hasGateway, gateways, err := server.GetPeers(nodecfg.MacAddress, nodecfg.Network, servercfg.GRPCAddress, nodecfg.IsDualStack == "yes", nodecfg.IsIngressGateway == "yes", nodecfg.IsServer == "yes")
-	if err != nil {
-		return err
-	}
+	//peers, hasGateway, gateways, err := server.GetPeers(nodecfg.MacAddress, nodecfg.Network, servercfg.GRPCAddress, nodecfg.IsDualStack == "yes", nodecfg.IsIngressGateway == "yes", nodecfg.IsServer == "yes")
+	//if err != nil {
+	//	return err
+	//}
 	privkey, err := RetrievePrivKey(network)
 	if err != nil {
 		return err
@@ -247,11 +246,11 @@ func SetWGConfig(network string, peerupdate bool) error {
 				return err
 			}
 		}
-		err = SetPeers(iface, &nodecfg, peers)
+		err = SetPeers(iface, &nodecfg, []wgtypes.PeerConfig{})
 	} else if peerupdate {
-		err = InitWireguard(&nodecfg, privkey, peers, hasGateway, gateways, true)
+		err = InitWireguard(&nodecfg, privkey, []wgtypes.PeerConfig{}, false, []string{}, true)
 	} else {
-		err = InitWireguard(&nodecfg, privkey, peers, hasGateway, gateways, false)
+		err = InitWireguard(&nodecfg, privkey, []wgtypes.PeerConfig{}, false, []string{}, false)
 	}
 	if nodecfg.DNSOn == "yes" {
 		_ = local.UpdateDNS(nodecfg.Interface, nodecfg.Network, servercfg.CoreDNSAddr)

test/main.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+
+	"github.com/gravitl/netmaker/models"
+	"github.com/gravitl/netmaker/netclient/config"
+	"github.com/gravitl/netmaker/netclient/functions"
+	"github.com/kr/pretty"
+)
+
+func main() {
+	cfg := &config.ClientConfig{}
+	cfg.Network = "short"
+	cfg.ReadConfig()
+	token, err := functions.Authenticate(cfg)
+	if err != nil {
+		log.Fatal(err)
+	} else {
+		log.Println("success", token)
+	}
+	url := "https://" + cfg.Server.API + "/api/nodes/" + cfg.Network + "/" + cfg.Node.ID
+
+	response, err := api("", http.MethodGet, url, token)
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(response.StatusCode, response.Status)
+	if response.StatusCode != http.StatusOK {
+		bytes, err := io.ReadAll(response.Body)
+		if err != nil {
+			fmt.Println(err)
+		}
+		pretty.Println(string(bytes))
+	}
+	defer response.Body.Close()
+	node := models.Node{}
+	if err := json.NewDecoder(response.Body).Decode(&node); err != nil {
+		fmt.Println(err)
+	}
+	pretty.Println(node)
+}
+
+func api(data any, method, url, authorization string) (*http.Response, error) {
+	var request *http.Request
+	var err error
+	if data != "" {
+		payload, err := json.Marshal(data)
+		if err != nil {
+			return nil, fmt.Errorf("error encoding data %w", err)
+		}
+		request, err = http.NewRequest(method, url, bytes.NewBuffer(payload))
+		if err != nil {
+			return nil, fmt.Errorf("error creating http request %w", err)
+		}
+		request.Header.Set("Content-Type", "application/json")
+	} else {
+		request, err = http.NewRequest(method, url, nil)
+		if err != nil {
+			return nil, fmt.Errorf("error creating http request %w", err)
+		}
+	}
+	if authorization != "" {
+		request.Header.Set("authorization", "Bearer "+authorization)
+	}
+	client := http.Client{}
+	return client.Do(request)
+}