Merge pull request #1025 from gravitl/feature_v0.13.0_grpc

Feature v0.13.0 grpc

compose/docker-compose.contained.yml

@@ -20,14 +20,10 @@ services:
       SERVER_NAME: "broker.NETMAKER_BASE_DOMAIN"
       SERVER_HOST: "SERVER_PUBLIC_IP"
       SERVER_API_CONN_STRING: "api.NETMAKER_BASE_DOMAIN:443"
-      SERVER_GRPC_CONN_STRING: "grpc.NETMAKER_BASE_DOMAIN:443"
       COREDNS_ADDR: "SERVER_PUBLIC_IP"
-      GRPC_SSL: "on"
       DNS_MODE: "on"
       SERVER_HTTP_HOST: "api.NETMAKER_BASE_DOMAIN"
-      SERVER_GRPC_HOST: "grpc.NETMAKER_BASE_DOMAIN"
       API_PORT: "8081"
-      GRPC_PORT: "50051"
       CLIENT_MODE: "on"
       MASTER_KEY: "REPLACE_MASTER_KEY"
       CORS_ALLOWED_ORIGIN: "*"

compose/docker-compose.hostnetwork.yml

@@ -18,24 +18,18 @@ services:
     environment:
       SERVER_HOST: "SERVER_PUBLIC_IP"
       SERVER_API_CONN_STRING: "api.NETMAKER_BASE_DOMAIN:443"
-      SERVER_GRPC_CONN_STRING: "grpc.NETMAKER_BASE_DOMAIN:443"
       COREDNS_ADDR: "SERVER_PUBLIC_IP"
-      GRPC_SSL: "on"
       DNS_MODE: "on"
       SERVER_HTTP_HOST: "api.NETMAKER_BASE_DOMAIN"
-      SERVER_GRPC_HOST: "grpc.NETMAKER_BASE_DOMAIN"
       API_PORT: "8081"
-      GRPC_PORT: "50051"
       CLIENT_MODE: "on"
       MASTER_KEY: "REPLACE_MASTER_KEY"
-      SERVER_GRPC_WIREGUARD: "off"
       CORS_ALLOWED_ORIGIN: "*"
       DISPLAY_KEYS: "on"
       DATABASE: "sqlite"
       HOST_NETWORK: "on"
       NODE_ID: "netmaker-server-1"
       MANAGE_IPTABLES: "on"
-      PORT_FORWARD_SERVICES: ""
       VERBOSITY: "1"
   netmaker-ui:
     container_name: netmaker-ui

compose/docker-compose.nocaddy.yml

@@ -18,14 +18,10 @@ services:
     environment:
       SERVER_HOST: "SERVER_PUBLIC_IP"
       SERVER_API_CONN_STRING: "api.NETMAKER_BASE_DOMAIN:443"
-      SERVER_GRPC_CONN_STRING: "grpc.NETMAKER_BASE_DOMAIN:443"
       COREDNS_ADDR: "SERVER_PUBLIC_IP"
-      GRPC_SSL: "on"
       DNS_MODE: "on"
       SERVER_HTTP_HOST: "api.NETMAKER_BASE_DOMAIN"
-      SERVER_GRPC_HOST: "grpc.NETMAKER_BASE_DOMAIN"
       API_PORT: "8081"
-      GRPC_PORT: "50051"
       CLIENT_MODE: "on"
       MASTER_KEY: "REPLACE_MASTER_KEY"
       CORS_ALLOWED_ORIGIN: "*"
@@ -35,7 +31,6 @@ services:
       MQ_HOST: "mq"
       HOST_NETWORK: "off"
       MANAGE_IPTABLES: "on"
-      PORT_FORWARD_SERVICES: "mq"
       VERBOSITY: "1"
     ports:
       - "51821-51830:51821-51830/udp"

compose/docker-compose.nodns.yml

@@ -18,14 +18,10 @@ services:
     environment:
       SERVER_HOST: "SERVER_PUBLIC_IP"
       SERVER_API_CONN_STRING: "api.NETMAKER_BASE_DOMAIN:443"
-      SERVER_GRPC_CONN_STRING: "grpc.NETMAKER_BASE_DOMAIN:443"
       COREDNS_ADDR: "SERVER_PUBLIC_IP"
-      GRPC_SSL: "on"
       DNS_MODE: "off"
       SERVER_HTTP_HOST: "api.NETMAKER_BASE_DOMAIN"
-      SERVER_GRPC_HOST: "grpc.NETMAKER_BASE_DOMAIN"
       API_PORT: "8081"
-      GRPC_PORT: "50051"
       CLIENT_MODE: "on"
       MASTER_KEY: "REPLACE_MASTER_KEY"
       CORS_ALLOWED_ORIGIN: "*"
@@ -35,7 +31,6 @@ services:
       MQ_HOST: "mq"
       HOST_NETWORK: "off"
       MANAGE_IPTABLES: "on"
-      PORT_FORWARD_SERVICES: "mq"
       VERBOSITY: "1"
     ports:
       - "51821-51830:51821-51830/udp"

compose/docker-compose.reference.yml

@@ -16,23 +16,18 @@ services:
     restart: always
     network_mode: host # Must configure with very particular settngs for host networking to work. Do not just set on!
     environment:
-      SERVER_HOST: "" # All the Docker Compose files pre-populate this with HOST_IP, which you replace as part of the install instructions. This will set both HTTP and GRPC host.
-      SERVER_HTTP_HOST: "127.0.0.1" # Overrides SERVER_HOST if set. Useful for making HTTP and GRPC available via different interfaces/networks.
-      SERVER_GRPC_HOST: "127.0.0.1" # Overrides SERVER_HOST if set. Useful for making HTTP and GRPC available via different interfaces/networks.
+      SERVER_HOST: "" # All the Docker Compose files pre-populate this with HOST_IP, which you replace as part of the install instructions. This will set the HTTP host.
+      SERVER_HTTP_HOST: "127.0.0.1" # Overrides SERVER_HOST if set. Useful for making HTTP available via different interfaces/networks.
       API_PORT: 8081 # The HTTP API port for Netmaker. Used for API calls / communication from front end. If changed, need to change port of BACKEND_URL for netmaker-ui.
-      GRPC_PORT: 50051 # The GRPC port for Netmaker. Used for communications from nodes.
       CLIENT_MODE: "on" # on if netmaker should run its own client, off if not.
       MASTER_KEY: "secretkey" # The admin master key for accessing the API. Change this in any production installation.
       CORS_ALLOWED_ORIGIN: "*" # The "allowed origin" for API requests. Change to restrict where API requests can come from.
       REST_BACKEND: "on" # Enables the REST backend (API running on API_PORT at SERVER_HTTP_HOST). Change to "off" to turn off.
-      AGENT_BACKEND: "on" # Enables the AGENT backend (GRPC running on GRPC_PORT at SERVER_GRPC_HOST). Change to "off" to turn off.
       DNS_MODE: "on" # Enables DNS Mode, meaning config files will be generated for CoreDNS. Note, turning "off" does not remove CoreDNS. You still need to remove CoreDNS from compose file.
       DISABLE_REMOTE_IP_CHECK: "off" # If turned "on", Server will not set Host based on remote IP check. This is already overridden if SERVER_HOST is set. Turned "off" by default.
-      GRPC_SSL: "off" # Tells clients to use SSL to connect to GRPC. Switch to on to turn on.
       COREDNS_ADDR: "" # Address of the CoreDNS server. Defaults to SERVER_HOST
       DISPLAY_KEYS: "on" # Show keys permanently in UI (until deleted) as opposed to 1-time display.
       SERVER_API_CONN_STRING: "" # Changes the api connection string. IP:PORT format. By default is empty and uses SERVER_HOST:API_PORT
-      SERVER_GRPC_CONN_STRING: "" # Changes the grpc connection string. IP:PORT format. By default is empty and uses SERVER_HOST:GRPC_PORT
       RCE: "off" # Enables setting PostUp and PostDown (arbitrary commands) on nodes from the server. Off by default.
       NODE_ID: "" # Sets the name/id of the nodes that the server creates. Necessary for HA configurations to identify between servers (for instance, netmaker-1, netmaker-2, etc). For non-HA deployments, is not necessary.
       TELEMETRY: "on" # Whether or not to send telemetry data to help improve Netmaker. Switch to "off" to opt out of sending telemetry.

compose/docker-compose.yml

@@ -18,14 +18,10 @@ services:
     environment:
       SERVER_HOST: "SERVER_PUBLIC_IP"
       SERVER_API_CONN_STRING: "api.NETMAKER_BASE_DOMAIN:443"
-      SERVER_GRPC_CONN_STRING: "grpc.NETMAKER_BASE_DOMAIN:443"
       COREDNS_ADDR: "SERVER_PUBLIC_IP"
-      GRPC_SSL: "on"
       DNS_MODE: "on"
       SERVER_HTTP_HOST: "api.NETMAKER_BASE_DOMAIN"
-      SERVER_GRPC_HOST: "grpc.NETMAKER_BASE_DOMAIN"
       API_PORT: "8081"
-      GRPC_PORT: "50051"
       CLIENT_MODE: "on"
       MASTER_KEY: "REPLACE_MASTER_KEY"
       CORS_ALLOWED_ORIGIN: "*"
@@ -35,7 +31,6 @@ services:
       MQ_HOST: "mq"
       HOST_NETWORK: "off"
       MANAGE_IPTABLES: "on"
-      PORT_FORWARD_SERVICES: "mq"
       VERBOSITY: "1"
     ports:
       - "51821-51830:51821-51830/udp"

config/config.go

@@ -36,10 +36,6 @@ type ServerConfig struct {
 	APIConnString         string `yaml:"apiconn"`
 	APIHost               string `yaml:"apihost"`
 	APIPort               string `yaml:"apiport"`
-	GRPCConnString        string `yaml:"grpcconn"`
-	GRPCHost              string `yaml:"grpchost"`
-	GRPCPort              string `yaml:"grpcport"`
-	GRPCSecure            string `yaml:"grpcsecure"`
 	MQHOST                string `yaml:"mqhost"`
 	MasterKey             string `yaml:"masterkey"`
 	DNSKey                string `yaml:"dnskey"`
@@ -51,7 +47,6 @@ type ServerConfig struct {
 	ClientMode            string `yaml:"clientmode"`
 	DNSMode               string `yaml:"dnsmode"`
 	DisableRemoteIPCheck  string `yaml:"disableremoteipcheck"`
-	GRPCSSL               string `yaml:"grpcssl"`
 	Version               string `yaml:"version"`
 	SQLConn               string `yaml:"sqlconn"`
 	Platform              string `yaml:"platform"`
@@ -71,7 +66,6 @@ type ServerConfig struct {
 	ManageIPTables        string `yaml:"manageiptables"`
 	PortForwardServices   string `yaml:"portforwardservices"`
 	HostNetwork           string `yaml:"hostnetwork"`
-	CommsCIDR             string `yaml:"commscidr"`
 	MQPort                string `yaml:"mqport"`
 	Server                string `yaml:"server"`
 }

config/environments/dev.yaml

@@ -1,8 +1,6 @@
 server:
   apihost: "" # defaults to 127.0.0.1 or remote ip (SERVER_HOST) if DisableRemoteIPCheck is not set to true. SERVER_API_HOST if set
   apiport: "" # defaults to 8081 or HTTP_PORT (if set)
-  grpchost: "" # defaults to 127.0.0.1 or remote ip (SERVER_HOST) if DisableRemoteIPCheck is not set to true. SERVER_GRPC_HOST if set.
-  grpcport: "" # defaults to 50051 or GRPC_PORT (if set)
   masterkey: "" # defaults to 'secretkey' or MASTER_KEY (if set)
   allowedorigin: "" # defaults to '*' or CORS_ALLOWED_ORIGIN (if set)
   restbackend: "" # defaults to "on" or REST_BACKEND (if set)

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/config/dnsconfig/netmaker.hosts

@@ -1 +1,2 @@
-10.0.0.2         testnode.skynet myhost.skynet
+10.0.0.1         testnode.skynet
+10.0.0.2         myhost.skynet

controllers/config/environments/dev.yaml

@@ -1,7 +1,6 @@
 server:
   host: "localhost"
   apiport: "8081"
-  grpcport: "50051"
   masterkey: ""
   allowedorigin: "*"
   restbackend: true            

controllers/network.go

@@ -3,7 +3,6 @@ package controller
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"net/http"
 	"strings"
 
@@ -15,7 +14,6 @@ import (
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/mq"
 	"github.com/gravitl/netmaker/servercfg"
-	"github.com/gravitl/netmaker/serverctl"
 )
 
 // ALL_NETWORK_ACCESS - represents all networks
@@ -84,10 +82,6 @@ func getNetwork(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
 	netname := params["networkname"]
-	if isCommsEdit(w, r, netname) {
-		return
-	}
-
 	network, err := logic.GetNetwork(netname)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -105,10 +99,6 @@ func keyUpdate(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
 	netname := params["networkname"]
-	if isCommsEdit(w, r, netname) {
-		return
-	}
-
 	network, err := logic.KeyUpdate(netname)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -295,10 +285,6 @@ func deleteNetwork(w http.ResponseWriter, r *http.Request) {
 
 	var params = mux.Vars(r)
 	network := params["networkname"]
-	if isCommsEdit(w, r, network) {
-		return
-	}
-
 	err := logic.DeleteNetwork(network)
 	if err != nil {
 		errtype := "badrequest"
@@ -333,8 +319,7 @@ func createNetwork(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if servercfg.IsClientMode() != "off" {
-		var node models.Node
-		node, err = logic.ServerJoin(&network)
+		_, err := logic.ServerJoin(&network)
 		if err != nil {
 			logic.DeleteNetwork(network.NetID)
 			if err == nil {
@@ -343,7 +328,6 @@ func createNetwork(w http.ResponseWriter, r *http.Request) {
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
-		getServerAddrs(&node)
 	}
 
 	logger.Log(1, r.Header.Get("user"), "created network", network.NetID)
@@ -358,9 +342,6 @@ func createAccessKey(w http.ResponseWriter, r *http.Request) {
 	var accesskey models.AccessKey
 	//start here
 	netname := params["networkname"]
-	if isCommsEdit(w, r, netname) {
-		return
-	}
 	network, err := logic.GetParentNetwork(netname)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -413,21 +394,3 @@ func deleteAccessKey(w http.ResponseWriter, r *http.Request) {
 	logger.Log(1, r.Header.Get("user"), "deleted access key", keyname, "on network,", netname)
 	w.WriteHeader(http.StatusOK)
 }
-
-func isCommsEdit(w http.ResponseWriter, r *http.Request, netname string) bool {
-	if netname == serverctl.COMMS_NETID {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("cannot access comms network"), "internal"))
-		return true
-	}
-	return false
-}
-
-func filterCommsNetwork(networks []models.Network) []models.Network {
-	var filterdNets []models.Network
-	for i := range networks {
-		if networks[i].IsComms != "yes" && networks[i].NetID != servercfg.GetCommsID() {
-			filterdNets = append(filterdNets, networks[i])
-		}
-	}
-	return filterdNets
-}

controllers/network_test.go

@@ -7,7 +7,6 @@ import (
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/serverctl"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -301,5 +300,4 @@ func createNet() {
 	if err != nil {
 		logic.CreateNetwork(network)
 	}
-	serverctl.InitializeCommsNetwork()
 }

controllers/node.go

@@ -19,20 +19,20 @@ import (
 
 func nodeHandlers(r *mux.Router) {
 
-	r.HandleFunc("/api/nodes", authorize(false, "user", http.HandlerFunc(getAllNodes))).Methods("GET")
-	r.HandleFunc("/api/nodes/{network}", authorize(true, "network", http.HandlerFunc(getNetworkNodes))).Methods("GET")
-	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(getNode))).Methods("GET")
-	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
-	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
-	r.HandleFunc("/api/nodes/{network}/{nodeid}/createrelay", authorize(true, "user", http.HandlerFunc(createRelay))).Methods("POST")
-	r.HandleFunc("/api/nodes/{network}/{nodeid}/deleterelay", authorize(true, "user", http.HandlerFunc(deleteRelay))).Methods("DELETE")
-	r.HandleFunc("/api/nodes/{network}/{nodeid}/creategateway", authorize(true, "user", http.HandlerFunc(createEgressGateway))).Methods("POST")
-	r.HandleFunc("/api/nodes/{network}/{nodeid}/deletegateway", authorize(true, "user", http.HandlerFunc(deleteEgressGateway))).Methods("DELETE")
+	r.HandleFunc("/api/nodes", authorize(false, false, "user", http.HandlerFunc(getAllNodes))).Methods("GET")
+	r.HandleFunc("/api/nodes/{network}", authorize(false, true, "network", http.HandlerFunc(getNetworkNodes))).Methods("GET")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, true, "node", http.HandlerFunc(getNode))).Methods("GET")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(false, true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/createrelay", authorize(false, true, "user", http.HandlerFunc(createRelay))).Methods("POST")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/deleterelay", authorize(false, true, "user", http.HandlerFunc(deleteRelay))).Methods("DELETE")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/creategateway", authorize(false, true, "user", http.HandlerFunc(createEgressGateway))).Methods("POST")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/deletegateway", authorize(false, true, "user", http.HandlerFunc(deleteEgressGateway))).Methods("DELETE")
 	r.HandleFunc("/api/nodes/{network}/{nodeid}/createingress", securityCheck(false, http.HandlerFunc(createIngressGateway))).Methods("POST")
 	r.HandleFunc("/api/nodes/{network}/{nodeid}/deleteingress", securityCheck(false, http.HandlerFunc(deleteIngressGateway))).Methods("DELETE")
-	r.HandleFunc("/api/nodes/{network}/{nodeid}/approve", authorize(true, "user", http.HandlerFunc(uncordonNode))).Methods("POST")
-	r.HandleFunc("/api/nodes/{network}", createNode).Methods("POST")
-	r.HandleFunc("/api/nodes/adm/{network}/lastmodified", authorize(true, "network", http.HandlerFunc(getLastModified))).Methods("GET")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/approve", authorize(false, true, "user", http.HandlerFunc(uncordonNode))).Methods("POST")
+	r.HandleFunc("/api/nodes/{network}", nodeauth(http.HandlerFunc(createNode))).Methods("POST")
+	r.HandleFunc("/api/nodes/adm/{network}/lastmodified", authorize(false, true, "network", http.HandlerFunc(getLastModified))).Methods("GET")
 	r.HandleFunc("/api/nodes/adm/{network}/authenticate", authenticate).Methods("POST")
 }
 
@@ -131,6 +131,51 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 	}
 }
 
+// auth middleware for api calls from nodes where node is has not yet joined the server (register, join)
+func nodeauth(next http.Handler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		bearerToken := r.Header.Get("Authorization")
+		var tokenSplit = strings.Split(bearerToken, " ")
+		var token = ""
+		if len(tokenSplit) < 2 {
+			errorResponse := models.ErrorResponse{
+				Code: http.StatusUnauthorized, Message: "W1R3: You are unauthorized to access this endpoint.",
+			}
+			returnErrorResponse(w, r, errorResponse)
+			return
+		} else {
+			token = tokenSplit[1]
+		}
+		found := false
+		networks, err := logic.GetNetworks()
+		if err != nil {
+			logger.Log(0, "no networks", err.Error())
+			errorResponse := models.ErrorResponse{
+				Code: http.StatusNotFound, Message: "no networks",
+			}
+			returnErrorResponse(w, r, errorResponse)
+			return
+		}
+		for _, network := range networks {
+			for _, key := range network.AccessKeys {
+				if key.Value == token {
+					found = true
+					break
+				}
+			}
+		}
+		if !found {
+			logger.Log(0, "valid access key not found")
+			errorResponse := models.ErrorResponse{
+				Code: http.StatusUnauthorized, Message: "You are unauthorized to access this endpoint.",
+			}
+			returnErrorResponse(w, r, errorResponse)
+			return
+		}
+		next.ServeHTTP(w, r)
+	}
+}
+
 //The middleware for most requests to the API
 //They all pass  through here first
 //This will validate the JWT (or check for master token)
@@ -138,7 +183,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 //even if it's technically ok
 //This is kind of a poor man's RBAC. There's probably a better/smarter way.
 //TODO: Consider better RBAC implementations
-func authorize(networkCheck bool, authNetwork string, next http.Handler) http.HandlerFunc {
+func authorize(nodesAllowed, networkCheck bool, authNetwork string, next http.Handler) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		var errorResponse = models.ErrorResponse{
 			Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
@@ -176,6 +221,14 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
 				returnErrorResponse(w, r, errorResponse)
 				return
 			}
+			//check if node instead of user
+			if nodesAllowed {
+				// TODO --- should ensure that node is only operating on itself
+				if _, _, _, err := logic.VerifyToken(authToken); err == nil {
+					next.ServeHTTP(w, r)
+					return
+				}
+			}
 
 			var isAuthorized = false
 			var nodeID = ""
@@ -329,10 +382,6 @@ func getNode(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if logic.IsNodeInComms(&node) {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
 	logger.Log(2, r.Header.Get("user"), "fetched node", params["nodeid"])
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
@@ -395,9 +444,12 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-
+	node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
 	validKey := logic.IsKeyValid(networkName, node.AccessKey)
-
 	if !validKey {
 		// Check to see if network will allow manual sign up
 		// may want to switch this up with the valid key check and avoid a DB call that way.
@@ -411,6 +463,26 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 	}
+	key, keyErr := logic.RetrievePublicTrafficKey()
+	if keyErr != nil {
+		logger.Log(0, "error retrieving key: ", keyErr.Error())
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	if key == nil {
+		logger.Log(0, "error: server traffic key is nil")
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	if node.TrafficKeys.Mine == nil {
+		logger.Log(0, "error: node traffic key is nil")
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	node.TrafficKeys = models.TrafficKeys{
+		Mine:   node.TrafficKeys.Mine,
+		Server: key,
+	}
 
 	err = logic.CreateNode(&node)
 	if err != nil {
@@ -660,12 +732,21 @@ func runServerUpdate(node *models.Node, ifaceDelta bool) error {
 	return nil
 }
 
-func filterCommsNodes(nodes []models.Node) []models.Node {
-	var filterdNodes []models.Node
-	for i := range nodes {
-		if !logic.IsNodeInComms(&nodes[i]) {
-			filterdNodes = append(filterdNodes, nodes[i])
+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)
 		}
-	}
-	return filterdNodes
+
+		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")
-			}
-		}
-	}()
-}

controllers/server.go

@@ -22,7 +22,7 @@ func serverHandlers(r *mux.Router) {
 	// r.HandleFunc("/api/server/addnetwork/{network}", securityCheckServer(true, http.HandlerFunc(addNetwork))).Methods("POST")
 	r.HandleFunc("/api/server/getconfig", securityCheckServer(false, http.HandlerFunc(getConfig))).Methods("GET")
 	r.HandleFunc("/api/server/removenetwork/{network}", securityCheckServer(true, http.HandlerFunc(removeNetwork))).Methods("DELETE")
-	r.HandleFunc("/api/server/register", http.HandlerFunc(register)).Methods("POST")
+	r.HandleFunc("/api/server/register", nodeauth(http.HandlerFunc(register))).Methods("POST")
 }
 
 //Security check is middleware for every function and just checks to make sure that its the master calling
@@ -115,18 +115,6 @@ func getConfig(w http.ResponseWriter, r *http.Request) {
 func register(w http.ResponseWriter, r *http.Request) {
 	logger.Log(2, "processing registration request")
 	w.Header().Set("Content-Type", "application/json")
-	bearerToken := r.Header.Get("Authorization")
-	var tokenSplit = strings.Split(bearerToken, " ")
-	var token = ""
-	if len(tokenSplit) < 2 {
-		errorResponse := models.ErrorResponse{
-			Code: http.StatusUnauthorized, Message: "W1R3: You are unauthorized to access this endpoint.",
-		}
-		returnErrorResponse(w, r, errorResponse)
-		return
-	} else {
-		token = tokenSplit[1]
-	}
 	//decode body
 	var request config.RegisterRequest
 	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
@@ -137,32 +125,6 @@ func register(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, errorResponse)
 		return
 	}
-	found := false
-	networks, err := logic.GetNetworks()
-	if err != nil {
-		logger.Log(0, "no networks", err.Error())
-		errorResponse := models.ErrorResponse{
-			Code: http.StatusNotFound, Message: "no networks",
-		}
-		returnErrorResponse(w, r, errorResponse)
-		return
-	}
-	for _, network := range networks {
-		for _, key := range network.AccessKeys {
-			if key.Value == token {
-				found = true
-				break
-			}
-		}
-	}
-	if !found {
-		logger.Log(0, "valid access key not found")
-		errorResponse := models.ErrorResponse{
-			Code: http.StatusUnauthorized, Message: "You are unauthorized to access this endpoint.",
-		}
-		returnErrorResponse(w, r, errorResponse)
-		return
-	}
 	cert, ca, err := genCerts(&request.Key, &request.CommonName)
 	if err != nil {
 		logger.Log(0, "failed to generater certs ", err.Error())

controllers/user.go

@@ -12,7 +12,6 @@ import (
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/servercfg"
 )
 
 func userHandlers(r *mux.Router) {
@@ -167,11 +166,6 @@ func createUser(w http.ResponseWriter, r *http.Request) {
 	// get node from body of request
 	_ = json.NewDecoder(r.Body).Decode(&user)
 
-	if !user.IsAdmin && isAddingComms(user.Networks) {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("can not add comms network to non admin"), "badrequest"))
-		return
-	}
-
 	user, err := logic.CreateUser(user)
 
 	if err != nil {
@@ -200,11 +194,6 @@ func updateUserNetworks(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if !userchange.IsAdmin && isAddingComms(userchange.Networks) {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("can not add comms network to non admin"), "badrequest"))
-		return
-	}
-
 	err = logic.UpdateUserNetworks(userchange.Networks, userchange.IsAdmin, &user)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
@@ -229,10 +218,6 @@ func updateUser(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(fmt.Errorf("can not update user info for oauth user %s", username), "forbidden"))
 		return
 	}
-	if !user.IsAdmin && isAddingComms(user.Networks) {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("can not add comms network to non admin"), "badrequest"))
-		return
-	}
 	var userchange models.User
 	// we decode our body request params
 	err = json.NewDecoder(r.Body).Decode(&userchange)
@@ -302,13 +287,3 @@ func deleteUser(w http.ResponseWriter, r *http.Request) {
 	logger.Log(1, username, "was deleted")
 	json.NewEncoder(w).Encode(params["username"] + " deleted.")
 }
-
-func isAddingComms(networks []string) bool {
-	commsID := servercfg.GetCommsID()
-	for i := range networks {
-		if networks[i] == commsID {
-			return true
-		}
-	}
-	return false
-}

dev.yaml

@@ -0,0 +1,42 @@
+server:
+  corednsaddr: ""
+  apiconn: "api.ping.clustercat.com:443"
+  apihost: ""
+  apiport: "8081"
+  grpcconn: "grpc.ping.clustercat.com:443"
+  grpchost: ""
+  grpcport: "50051"
+  grpcsecure: "on"
+  mqhost: "localhost"
+  masterkey: "secretkey"
+  dnskey: ""
+  allowedorigin: "*"
+  nodeid: "netmaker"
+  restbackend: "on"
+  agentbackend: "on"
+  messagequeuebackend: "on"
+  clientmode: "on"
+  dnsmode: "on"
+  disableremoteipcheck: ""
+  grpcssl: "on"
+  version: ""
+  sqlconn: ""
+  platform: ""
+  database: "sqlite"
+  defaultnodelimit: ""
+  verbosity: 3
+  servercheckininterval: ""
+  authprovider: ""
+  clientid: ""
+  clientsecret: ""
+  frontendurl: ""
+  displaykeys: ""
+  azuretenant: ""
+  rce: "off"
+  debug: ""
+  telemetry: ""
+  manageiptables: "off"
+  portforwardservices: ""
+  hostnetwork: "off"
+  mqport: ""
+  server: "broker.ping.clustercat.com"

docker/Caddyfile

@@ -29,7 +29,3 @@ https://api.NETMAKER_BASE_DOMAIN {
         reverse_proxy http://127.0.0.1:8081
 }
 
-# gRPC
-https://grpc.NETMAKER_BASE_DOMAIN {
-        reverse_proxy h2c://127.0.0.1:50051
-}

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"

kube/components/netmaker-api.yaml

@@ -25,20 +25,12 @@ spec:
         env:
         - name: SERVER_API_CONN_STRING
           value: "api.nm.k8s.gravitl.com:443"
-        - name: SERVER_GRPC_CONN_STRING
-          value: "grpc.nm.k8s.gravitl.com:443"
         - name: COREDNS_ADDR
           value: "netmaker-dns"
-        - name: GRPC_SSL
-          value: "on"
         - name: SERVER_HTTP_HOST
           value: "api.nm.k8s.gravitl.com"
-        - name: SERVER_GRPC_HOST
-          value: "grpc.nm.k8s.gravitl.com"
         - name: API_PORT
           value: "8081"
-        - name: GRPC_PORT
-          value: "50051"
         - name: AGENT_BACKEND
           value: "off"
         - name: CLIENT_MODE
@@ -47,8 +39,6 @@ spec:
           value: "on"
         - name: MASTER_KEY
           value: "Unkn0wn!"
-        - name: SERVER_GRPC_WIREGUARD
-          value: "off"
         - name: MASTER_KEY
           value: "secretkey"
         - name: CORS_ALLOWED_ORIGIN

kube/components/netmaker-backend.yaml

@@ -25,26 +25,16 @@ spec:
         env:
         - name: SERVER_API_CONN_STRING
           value: "api.nm.k8s.gravitl.com:443"
-        - name: SERVER_GRPC_CONN_STRING
-          value: "grpc.nm.k8s.gravitl.com:443"
         - name: COREDNS_ADDR
           value: "10.152.183.53"
-        - name: GRPC_SSL
-          value: "on"
         - name: SERVER_HTTP_HOST
           value: "api.k8s.gravitl.com"
-        - name: SERVER_GRPC_HOST
-          value: "grpc.k8s.gravitl.com"
         - name: API_PORT
           value: "8081"
-        - name: GRPC_PORT
-          value: "443"
         - name: CLIENT_MODE
           value: "off"
         - name: MASTER_KEY
           value: "Unkn0wn!"
-        - name: SERVER_GRPC_WIREGUARD
-          value: "off"
         - name: MASTER_KEY
           value: "secretkey"
         - name: CORS_ALLOWED_ORIGIN
@@ -97,7 +87,6 @@ kind: Service
 metadata:
   labels:
     app: netmaker-backend
-  name: netmaker-grpc
 spec:
   ports:
   - port: 443

kube/components/netmaker-template.yaml.backup

@@ -84,26 +84,16 @@ spec:
         env:
         - name: SERVER_API_CONN_STRING
           value: "api.NETMAKER_BASE_DOMAIN:443"
-        - name: SERVER_GRPC_CONN_STRING
-          value: "grpc.NETMAKER_BASE_DOMAIN:443"
         - name: COREDNS_ADDR
           value: "10.152.183.53"
-        - name: GRPC_SSL
-          value: "on"
         - name: SERVER_HTTP_HOST
           value: "api.NETMAKER_BASE_DOMAIN"
-        - name: SERVER_GRPC_HOST
-          value: "grpc.NETMAKER_BASE_DOMAIN"
         - name: API_PORT
           value: "8081"
-        - name: GRPC_PORT
-          value: "443"
         - name: CLIENT_MODE
           value: "off"
         - name: MASTER_KEY
           value: "Unkn0wn!"
-        - name: SERVER_GRPC_WIREGUARD
-          value: "off"
         - name: MASTER_KEY
           value: "secretkey"
         - name: CORS_ALLOWED_ORIGIN

kube/netmaker-template-udp.yaml

@@ -56,24 +56,16 @@ spec:
         env:
         - name: SERVER_API_CONN_STRING
           value: "api.NETMAKER_BASE_DOMAIN:443"
-        - name: SERVER_GRPC_CONN_STRING
-          value: "grpc.NETMAKER_BASE_DOMAIN:443"
         - name: COREDNS_ADDR
           value: "10.152.183.53"
         - name: POD_IP
           valueFrom:
             fieldRef:
               fieldPath: status.podIP
-        - name: GRPC_SSL
-          value: "on"
         - name: SERVER_HTTP_HOST
           value: "api.NETMAKER_BASE_DOMAIN:443"
-        - name: SERVER_GRPC_HOST
-          value: "grpc.NETMAKER_BASE_DOMAIN:443"
         - name: API_PORT
           value: "8081"
-        - name: GRPC_PORT
-          value: "443"
         - name: CLIENT_MODE
           value: "off"
         - name: MASTER_KEY

kube/netmaker-template.yaml

@@ -39,24 +39,16 @@ spec:
         env:
         - name: SERVER_API_CONN_STRING
           value: "api.NETMAKER_BASE_DOMAIN:443"
-        - name: SERVER_GRPC_CONN_STRING
-          value: "grpc.NETMAKER_BASE_DOMAIN:443"
         - name: COREDNS_ADDR
           value: "10.152.183.53"
         - name: POD_IP
           valueFrom:
             fieldRef:
               fieldPath: status.podIP
-        - name: GRPC_SSL
-          value: "on"
         - name: SERVER_HTTP_HOST
           value: "api.NETMAKER_BASE_DOMAIN"
-        - name: SERVER_GRPC_HOST
-          value: "grpc.NETMAKER_BASE_DOMAIN"
         - name: API_PORT
           value: "8081"
-        - name: GRPC_PORT
-          value: "80"
         - name: CLIENT_MODE
           value: "off"
         - name: MASTER_KEY

logger/util.go

@@ -1,9 +1,9 @@
 package logger
 
 import (
-	"os"
-	"strconv"
 	"strings"
+
+	"github.com/gravitl/netmaker/servercfg"
 )
 
 // Verbosity - current logging verbosity level (optionally set)
@@ -25,12 +25,6 @@ func getVerbose() int32 {
 	if Verbosity >= 1 && Verbosity <= 3 {
 		return int32(Verbosity)
 	}
-	level, err := strconv.Atoi(os.Getenv("VERBOSITY"))
-	if err != nil || level < 0 {
-		level = 0
-	}
-	if level > 3 {
-		level = 3
-	}
-	return int32(level)
+	Verbosity = int(servercfg.GetVerbosity())
+	return int32(Verbosity)
 }

logic/accesskeys.go

@@ -54,10 +54,8 @@ func CreateAccessKey(accesskey models.AccessKey, network models.Network) (models
 	var accessToken models.AccessToken
 	s := servercfg.GetServerConfig()
 	servervals := models.ServerConfig{
-		GRPCConnString: s.GRPCConnString,
-		GRPCSSL:        s.GRPCSSL,
-		Server:         s.Server,
-		APIConnString:  s.APIConnString,
+		Server:        s.Server,
+		APIConnString: s.APIConnString,
 	}
 	accessToken.ServerConfig = servervals
 	accessToken.ClientConfig.Network = netID
@@ -145,7 +143,7 @@ func DecrimentKey(networkName string, keyvalue string) {
 	var network models.Network
 
 	network, err := GetParentNetwork(networkName)
-	if err != nil || network.IsComms == "yes" {
+	if err != nil {
 		return
 	}
 
@@ -178,9 +176,6 @@ func IsKeyValid(networkname string, keyvalue string) bool {
 		return false
 	}
 	accesskeys := network.AccessKeys
-	if network.IsComms == "yes" {
-		accesskeys = getAllAccessKeys()
-	}
 
 	var key models.AccessKey
 	foundkey := false

logic/jwts.go

@@ -98,7 +98,7 @@ func VerifyUserToken(tokenString string) (username string, networks []string, is
 	return "", nil, false, err
 }
 
-// VerifyToken - gRPC [nodes] Only
+// VerifyToken - [nodes] Only
 func VerifyToken(tokenString string) (nodeID string, mac string, network string, err error) {
 	claims := &models.Claims{}
 

logic/nodes.go

@@ -630,11 +630,6 @@ func IsLocalServer(node *models.Node) bool {
 	return node.ID != "" && local.ID == node.ID
 }
 
-// IsNodeInComms returns if node is in comms network or not
-func IsNodeInComms(node *models.Node) bool {
-	return node.Network == servercfg.GetCommsID() && node.IsServer != "yes"
-}
-
 // validateServer - make sure servers dont change port or address
 func validateServer(currentNode, newNode *models.Node) bool {
 	return (newNode.Address == currentNode.Address &&

logic/server.go

@@ -43,7 +43,7 @@ func ServerJoin(networkSettings *models.Network) (models.Node, error) {
 	}
 	var ishub = "no"
 
-	if networkSettings.IsPointToSite == "yes" || networkSettings.IsComms == "yes" {
+	if networkSettings.IsPointToSite == "yes" {
 		nodes, err := GetNetworkNodes(networkSettings.NetID)
 		if err != nil || nodes == nil {
 			ishub = "yes"

logic/serverconf.go

@@ -72,32 +72,3 @@ func StoreJWTSecret(privateKey string) error {
 	}
 	return database.Insert("nm-jwt-secret", string(data), database.SERVERCONF_TABLE_NAME)
 }
-
-// FetchCommsNetID - fetches comms netid from db
-func FetchCommsNetID() (string, error) {
-	var dbData string
-	var err error
-	var fetchedData = serverData{}
-	dbData, err = database.FetchRecord(database.SERVERCONF_TABLE_NAME, "nm-comms-id")
-	if err != nil {
-		return "", err
-	}
-	err = json.Unmarshal([]byte(dbData), &fetchedData)
-	if err != nil {
-		return "", err
-	}
-	return fetchedData.PrivateKey, nil
-}
-
-// StoreCommsNetID - stores server comms network netid if needed
-func StoreCommsNetID(netid string) error {
-	var newData = serverData{}
-	var err error
-	var data []byte
-	newData.PrivateKey = netid
-	data, err = json.Marshal(&newData)
-	if err != nil {
-		return err
-	}
-	return database.Insert("nm-comms-id", string(data), database.SERVERCONF_TABLE_NAME)
-}

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"
@@ -43,10 +40,10 @@ func main() {
 	setupConfig(*absoluteConfigPath)
 	servercfg.SetVersion(version)
 	fmt.Println(models.RetrieveLogo()) // print the logo
-	initialize()                       // initial db and grpc server
+	initialize()                       // initial db and acls; gen cert if required
 	setGarbageCollection()
 	defer database.CloseDB()
-	startControllers() // start the grpc or rest endpoints
+	startControllers() // start the api endpoint and mq
 }
 
 func setupConfig(absoluteConfigPath string) {
@@ -127,18 +124,6 @@ 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.IsDNSMode() {
 		err := logic.SetDNS()
 		if err != nil {
@@ -170,52 +155,6 @@ func startControllers() {
 	waitnetwork.Wait()
 }
 
-func runGRPC(wg *sync.WaitGroup) {
-
-	defer wg.Done()
-
-	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())
-	}
-
-	s := grpc.NewServer(
-		authServerUnaryInterceptor(),
-	)
-	// Create NodeService type
-	srv := &controller.NodeServiceServer{}
-
-	// 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.")
-}
-
 // Should we be using a context vice a waitgroup????????????
 func runMessageQueue(wg *sync.WaitGroup) {
 	defer wg.Done()
@@ -231,10 +170,6 @@ func runMessageQueue(wg *sync.WaitGroup) {
 	client.Disconnect(250)
 }
 
-func authServerUnaryInterceptor() grpc.ServerOption {
-	return grpc.UnaryInterceptor(controller.AuthServerUnaryInterceptor)
-}
-
 func setGarbageCollection() {
 	_, gcset := os.LookupEnv("GOGC")
 	if !gcset {

models/accessToken.go

@@ -12,8 +12,6 @@ type ClientConfig struct {
 }
 
 type ServerConfig struct {
-	GRPCConnString string `json:"grpcconn"`
-	GRPCSSL        string `json:"grpcssl"`
-	Server         string `json:"server"`
-	APIConnString  string `json:"apiconnstring"`
+	Server        string `json:"server"`
+	APIConnString string `json:"apiconnstring"`
 }

models/intclient.go

@@ -12,7 +12,6 @@ type IntClient struct {
 	ServerAPIPort        string `json:"serverapiport" bson:"serverapiport"`
 	ServerPrivateAddress string `json:"serverprivateaddress" bson:"serverprivateaddress"`
 	ServerWGPort         string `json:"serverwgport" bson:"serverwgport"`
-	ServerGRPCPort       string `json:"servergrpcport" bson:"servergrpcport"`
 	ServerKey            string `json:"serverkey" bson:"serverkey"`
 	IsServer             string `json:"isserver" bson:"isserver"`
 }

models/network.go

@@ -25,14 +25,11 @@ type Network struct {
 	IsIPv4              string      `json:"isipv4" bson:"isipv4" validate:"checkyesorno"`
 	IsIPv6              string      `json:"isipv6" bson:"isipv6" validate:"checkyesorno"`
 	IsPointToSite       string      `json:"ispointtosite" bson:"ispointtosite" validate:"checkyesorno"`
-	IsComms             string      `json:"iscomms" bson:"iscomms" validate:"checkyesorno"`
 	LocalRange          string      `json:"localrange" bson:"localrange" validate:"omitempty,cidr"`
 	DefaultUDPHolePunch string      `json:"defaultudpholepunch" bson:"defaultudpholepunch" validate:"checkyesorno"`
 	DefaultExtClientDNS string      `json:"defaultextclientdns" bson:"defaultextclientdns"`
 	DefaultMTU          int32       `json:"defaultmtu" bson:"defaultmtu"`
-	// consider removing - may be depreciated
-	DefaultServerAddrs []ServerAddr `json:"defaultserveraddrs" bson:"defaultserveraddrs" yaml:"defaultserveraddrs"`
-	DefaultACL         string       `json:"defaultacl" bson:"defaultacl" yaml:"defaultacl" validate:"checkyesorno"`
+	DefaultACL          string      `json:"defaultacl" bson:"defaultacl" yaml:"defaultacl" validate:"checkyesorno"`
 }
 
 // SaveData - sensitive fields of a network that should be kept the same
@@ -61,9 +58,6 @@ func (network *Network) SetDefaults() {
 	if network.IsPointToSite == "" {
 		network.IsPointToSite = "no"
 	}
-	if network.IsComms == "" {
-		network.IsComms = "no"
-	}
 	if network.DefaultInterface == "" {
 		if len(network.NetID) < 13 {
 			network.DefaultInterface = "nm-" + network.NetID

models/structs.go

@@ -101,9 +101,7 @@ type DisplayKey struct {
 
 // GlobalConfig - global config
 type GlobalConfig struct {
-	Name       string `json:"name" bson:"name"`
-	PortGRPC   string `json:"portgrpc" bson:"portgrpc"`
-	ServerGRPC string `json:"servergrpc" bson:"servergrpc"`
+	Name string `json:"name" bson:"name"`
 }
 
 // CheckInResponse - checkin response

mq/publishers.go

@@ -23,7 +23,7 @@ func PublishPeerUpdate(newNode *models.Node) error {
 	}
 	for _, node := range networkNodes {
 
-		if node.IsServer == "yes" || node.ID == newNode.ID {
+		if node.IsServer == "yes" {
 			continue
 		}
 		peerUpdate, err := logic.GetPeerUpdate(&node)
@@ -39,9 +39,7 @@ func PublishPeerUpdate(newNode *models.Node) error {
 		if err = publish(&node, fmt.Sprintf("peers/%s/%s", node.Network, node.ID), data); err != nil {
 			logger.Log(1, "failed to publish peer update for node", node.ID)
 		} else {
-			if node.Network != servercfg.GetCommsID() {
-				logger.Log(1, "sent peer update for node", node.Name, "on network:", node.Network)
-			}
+			logger.Log(1, "sent peer update for node", node.Name, "on network:", node.Network)
 		}
 	}
 	return nil

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/cli_options/cmds.go

@@ -26,10 +26,6 @@ func GetCommands(cliFlags []cli.Flag) []*cli.Command {
 					err = errors.New("no network provided")
 					return err
 				}
-				if cfg.Server.GRPCAddress == "" {
-					err = errors.New("no server address provided")
-					return err
-				}
 				err = command.Register(&cfg, pvtKey)
 				return err
 			},

netclient/cli_options/flags.go

@@ -112,18 +112,6 @@ func GetFlags(hostname string) []cli.Flag {
 			Value:   "",
 			Usage:   "Address + API Port (e.g. 1.2.3.4:8081) of Netmaker server.",
 		},
-		&cli.StringFlag{
-			Name:    "grpcserver",
-			EnvVars: []string{"NETCLIENT_GRPC_SERVER"},
-			Value:   "",
-			Usage:   "Address + GRPC Port (e.g. 1.2.3.4:50051) of Netmaker server.",
-		},
-		&cli.StringFlag{
-			Name:    "grpcssl",
-			EnvVars: []string{"NETCLIENT_GRPCSSL"},
-			Value:   "",
-			Usage:   "Tells clients to use SSL to connect to GRPC if 'on'. Disable if 'off'. Off by default.",
-		},
 		&cli.StringFlag{
 			Name:    "key",
 			Aliases: []string{"k"},

netclient/command/commands.go

@@ -10,40 +10,11 @@ import (
 	"github.com/gravitl/netmaker/netclient/ncutils"
 )
 
-// JoinComms -- Join the message queue comms network if it doesn't have it
-// tries to ping if already found locally, if fail ping pull for best effort for communication
-func JoinComms(cfg *config.ClientConfig) error {
-	commsCfg := &config.ClientConfig{}
-	commsCfg.Network = cfg.Server.CommsNetwork
-	commsCfg.Node.Network = cfg.Server.CommsNetwork
-	commsCfg.Server.AccessKey = cfg.Server.AccessKey
-	commsCfg.Server.GRPCAddress = cfg.Server.GRPCAddress
-	commsCfg.Server.GRPCSSL = cfg.Server.GRPCSSL
-	commsCfg.Server.CoreDNSAddr = cfg.Server.CoreDNSAddr
-	if commsCfg.ConfigFileExists() {
-		return nil
-	}
-	commsCfg.ReadConfig()
-
-	if len(commsCfg.Node.Name) == 0 {
-		if err := functions.JoinNetwork(commsCfg, "", true); err != nil {
-			return err
-		}
-	} else { // check if comms is currently reachable
-		if err := functions.PingServer(commsCfg); err != nil {
-			if err = Pull(commsCfg); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
 // Join - join command to run from cli
 func Join(cfg *config.ClientConfig, privateKey string) error {
 	var err error
 	//join network
-	err = functions.JoinNetwork(cfg, privateKey, false)
+	err = functions.JoinNetwork(cfg, privateKey)
 	if err != nil && !cfg.DebugOn {
 		if !strings.Contains(err.Error(), "ALREADY_INSTALLED") {
 			logger.Log(1, "error installing: ", err.Error())
@@ -93,13 +64,6 @@ func Leave(cfg *config.ClientConfig, force bool) error {
 	} else {
 		logger.Log(0, "success")
 	}
-	//nets, err := ncutils.GetSystemNetworks()
-	//if err == nil && len(nets) == 1 {
-	//if nets[0] == cfg.Node.CommID {
-	//logger.Log(1, "detected comms as remaining network, removing...")
-	//err = functions.LeaveNetwork(nets[0], true)
-	//}
-	//}
 	return err
 }
 

netclient/config/config.go

@@ -33,13 +33,10 @@ type ClientConfig struct {
 
 // ServerConfig - struct for dealing with the server information for a netclient
 type ServerConfig struct {
-	CoreDNSAddr  string `yaml:"corednsaddr"`
-	GRPCAddress  string `yaml:"grpcaddress"`
-	AccessKey    string `yaml:"accesskey"`
-	GRPCSSL      string `yaml:"grpcssl"`
-	CommsNetwork string `yaml:"commsnetwork"`
-	Server       string `yaml:"server"`
-	API          string `yaml:"api"`
+	CoreDNSAddr string `yaml:"corednsaddr"`
+	AccessKey   string `yaml:"accesskey"`
+	Server      string `yaml:"server"`
+	API         string `yaml:"api"`
 }
 
 // RegisterRequest - struct for registation with netmaker server
@@ -198,21 +195,12 @@ func GetCLIConfig(c *cli.Context) (ClientConfig, string, error) {
 			log.Println("error converting token json to object", tokenbytes)
 			return cfg, "", err
 		}
-
-		if accesstoken.ServerConfig.GRPCConnString != "" {
-			cfg.Server.GRPCAddress = accesstoken.ServerConfig.GRPCConnString
-		}
-
 		cfg.Network = accesstoken.ClientConfig.Network
 		cfg.Node.Network = accesstoken.ClientConfig.Network
 		cfg.Server.AccessKey = accesstoken.ClientConfig.Key
 		cfg.Node.LocalRange = accesstoken.ClientConfig.LocalRange
-		cfg.Server.GRPCSSL = accesstoken.ServerConfig.GRPCSSL
 		cfg.Server.Server = accesstoken.ServerConfig.Server
 		cfg.Server.API = accesstoken.ServerConfig.APIConnString
-		if c.String("grpcserver") != "" {
-			cfg.Server.GRPCAddress = c.String("grpcserver")
-		}
 		if c.String("key") != "" {
 			cfg.Server.AccessKey = c.String("key")
 		}
@@ -223,9 +211,6 @@ func GetCLIConfig(c *cli.Context) (ClientConfig, string, error) {
 		if c.String("localrange") != "" {
 			cfg.Node.LocalRange = c.String("localrange")
 		}
-		if c.String("grpcssl") != "" {
-			cfg.Server.GRPCSSL = c.String("grpcssl")
-		}
 		if c.String("corednsaddr") != "" {
 			cfg.Server.CoreDNSAddr = c.String("corednsaddr")
 		}
@@ -234,12 +219,10 @@ func GetCLIConfig(c *cli.Context) (ClientConfig, string, error) {
 		}
 
 	} else {
-		cfg.Server.GRPCAddress = c.String("grpcserver")
 		cfg.Server.AccessKey = c.String("key")
 		cfg.Network = c.String("network")
 		cfg.Node.Network = c.String("network")
 		cfg.Node.LocalRange = c.String("localrange")
-		cfg.Server.GRPCSSL = c.String("grpcssl")
 		cfg.Server.CoreDNSAddr = c.String("corednsaddr")
 		cfg.Server.API = c.String("apiserver")
 	}

netclient/functions/common.go

@@ -1,26 +1,25 @@
 package functions
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"net"
+	"net/http"
 	"os"
 	"strings"
 
-	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/daemon"
 	"github.com/gravitl/netmaker/netclient/local"
 	"github.com/gravitl/netmaker/netclient/ncutils"
 	"github.com/gravitl/netmaker/netclient/wireguard"
 	"golang.zx2c4.com/wireguard/wgctrl"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
 )
 
 // LINUX_APP_DATA_PATH - linux path
@@ -156,46 +155,25 @@ func LeaveNetwork(network string, force bool) error {
 	if err != nil {
 		return err
 	}
-	servercfg := cfg.Server
 	node := cfg.Node
-	if node.NetworkSettings.IsComms == "yes" && !force {
-		return errors.New("COMMS_NET - You are trying to leave the comms network. This will break network updates. Unless you re-join. If you really want to leave, run with --force=yes.")
-	}
-
 	if node.IsServer != "yes" {
-		var wcclient nodepb.NodeServiceClient
-		conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-			ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
+		token, err := Authenticate(cfg)
 		if err != nil {
-			log.Printf("Unable to establish client connection to "+servercfg.GRPCAddress+": %v", err)
+			return fmt.Errorf("unable to authenticate %w", err)
 		}
-		defer conn.Close()
-		wcclient = nodepb.NewNodeServiceClient(conn)
-
-		ctx, err := auth.SetJWT(wcclient, network)
+		url := "https://" + cfg.Server.API + "/api/nodes/" + cfg.Network + "/" + cfg.Node.ID
+		response, err := API("", http.MethodDelete, url, token)
 		if err != nil {
-			log.Printf("Failed to authenticate: %v", err)
-		} else { // handle client side
-			var header metadata.MD
-			nodeData, err := json.Marshal(&node)
-			if err == nil {
-				_, err = wcclient.DeleteNode(
-					ctx,
-					&nodepb.Object{
-						Data: string(nodeData),
-						Type: nodepb.NODE_TYPE,
-					},
-					grpc.Header(&header),
-				)
-				if err != nil {
-					logger.Log(1, "encountered error deleting node: ", err.Error())
-				} else {
-					logger.Log(1, "removed machine from ", node.Network, " network on remote server")
-				}
-			}
+			return fmt.Errorf("error deleting node on server %w", err)
+		}
+		if response.StatusCode == http.StatusOK {
+			logger.Log(0, "deleted node", cfg.Node.Name, " on network ", cfg.Network)
+		} else {
+			bodybytes, _ := ioutil.ReadAll(response.Body)
+			defer response.Body.Close()
+			return fmt.Errorf("error deleting node on server %s %s", response.Status, string(bodybytes))
 		}
 	}
-
 	wgClient, wgErr := wgctrl.New()
 	if wgErr == nil {
 		removeIface := cfg.Node.Interface
@@ -329,3 +307,61 @@ func WipeLocal(network string) error {
 func GetNetmakerPath() string {
 	return LINUX_APP_DATA_PATH
 }
+
+//API function to interact with netmaker api endpoints. response from endpoint is returned
+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)
+}
+
+// Authenticate authenticates with api to permit subsequent interactions with the api
+func Authenticate(cfg *config.ClientConfig) (string, error) {
+
+	pass, err := os.ReadFile(ncutils.GetNetclientPathSpecific() + "/secret-" + cfg.Network)
+	if err != nil {
+		return "", fmt.Errorf("could not read secrets file %w", err)
+	}
+	data := models.AuthParams{
+		MacAddress: cfg.Node.MacAddress,
+		ID:         cfg.Node.ID,
+		Password:   string(pass),
+	}
+	url := "https://" + cfg.Server.API + "/api/nodes/adm/" + cfg.Network + "/authenticate"
+	response, err := API(data, http.MethodPost, url, "")
+	if err != nil {
+		return "", err
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		bodybytes, _ := ioutil.ReadAll(response.Body)
+		return "", fmt.Errorf("failed to authenticate %s %s", response.Status, string(bodybytes))
+	}
+	resp := models.SuccessResponse{}
+	if err := json.NewDecoder(response.Body).Decode(&resp); err != nil {
+		return "", fmt.Errorf("error decoding respone %w", err)
+	}
+	tokenData := resp.Response.(map[string]interface{})
+	token := tokenData["AuthToken"]
+	return token.(string), nil
+}

netclient/functions/daemon.go

@@ -18,7 +18,6 @@ import (
 	mqtt "github.com/eclipse/paho.mqtt.golang"
 	"github.com/go-ping/ping"
 	"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/daemon"
@@ -72,7 +71,7 @@ func Daemon() error {
 	wg := sync.WaitGroup{}
 	ctx, cancel := context.WithCancel(context.Background())
 	wg.Add(1)
-	go Checkin(ctx, &wg, serverSet)
+	go Checkin(ctx, &wg)
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, syscall.SIGTERM, os.Interrupt)
 	<-quit
@@ -112,7 +111,6 @@ func UpdateKeys(nodeCfg *config.ClientConfig, client mqtt.Client) error {
 }
 
 // PingServer -- checks if server is reachable
-// use commsCfg only*
 func PingServer(cfg *config.ClientConfig) error {
 	pinger, err := ping.NewPinger(cfg.Server.Server)
 	if err != nil {
@@ -181,10 +179,9 @@ func messageQueue(ctx context.Context, server string) {
 }
 
 // setupMQTTSub creates a connection to broker and subscribes to topic
-// utilizes comms client configs to setup connections
 func setupMQTTSub(server string) mqtt.Client {
 	opts := mqtt.NewClientOptions()
-	opts.AddBroker("ssl://" + server + ":8883") // TODO get the appropriate port of the comms mq server
+	opts.AddBroker("ssl://" + server + ":8883")
 	opts.TLSConfig = NewTLSConfig(nil, server)
 	opts.SetDefaultPublishHandler(All)
 	opts.SetAutoReconnect(true)
@@ -231,7 +228,7 @@ func setupMQTTSub(server string) mqtt.Client {
 	client := mqtt.NewClient(opts)
 	tperiod := time.Now().Add(12 * time.Second)
 	for {
-		//if after 12 seconds, try a gRPC pull on the last try
+		//if after 12 seconds, try a pull on the last try
 		if time.Now().After(tperiod) {
 			networks, err := ncutils.GetSystemNetworks()
 			if err != nil {
@@ -325,7 +322,7 @@ func NewTLSConfig(cfg *config.ClientConfig, server string) *tls.Config {
 func setupMQTT(cfg *config.ClientConfig, publish bool) mqtt.Client {
 	opts := mqtt.NewClientOptions()
 	server := cfg.Server.Server
-	opts.AddBroker("ssl://" + server + ":8883") // TODO get the appropriate port of the comms mq server
+	opts.AddBroker("ssl://" + server + ":8883")
 	opts.TLSConfig = NewTLSConfig(cfg, "")
 	opts.SetDefaultPublishHandler(All)
 	opts.SetAutoReconnect(true)
@@ -362,7 +359,7 @@ func setupMQTT(cfg *config.ClientConfig, publish bool) mqtt.Client {
 	client := mqtt.NewClient(opts)
 	tperiod := time.Now().Add(12 * time.Second)
 	for {
-		//if after 12 seconds, try a gRPC pull on the last try
+		//if after 12 seconds, try a pull on the last try
 		if time.Now().After(tperiod) {
 			logger.Log(0, "running pull for ", cfg.Node.Network)
 			_, err := Pull(cfg.Node.Network, true)
@@ -451,16 +448,6 @@ func decryptMsg(nodeCfg *config.ClientConfig, msg []byte) ([]byte, error) {
 	return ncutils.DeChunk(msg, serverPubKey, diskKey)
 }
 
-func getServerAddress(cfg *config.ClientConfig) string {
-	var server models.ServerAddr
-	for _, server = range cfg.Node.NetworkSettings.DefaultServerAddrs {
-		if server.Address != "" && server.IsLeader {
-			break
-		}
-	}
-	return server.Address
-}
-
 // == Message Caches ==
 
 func insert(network, which, cache string) {

netclient/functions/join.go

@@ -1,15 +1,16 @@
 package functions
 
 import (
-	"context"
 	"crypto/rand"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
+	"io/ioutil"
 	"log"
+	"net/http"
 	"runtime"
 
-	nodepb "github.com/gravitl/netmaker/grpc"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
@@ -18,15 +19,13 @@ import (
 	"github.com/gravitl/netmaker/netclient/daemon"
 	"github.com/gravitl/netmaker/netclient/local"
 	"github.com/gravitl/netmaker/netclient/ncutils"
-	"github.com/gravitl/netmaker/netclient/server"
 	"github.com/gravitl/netmaker/netclient/wireguard"
 	"golang.org/x/crypto/nacl/box"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
-	"google.golang.org/grpc"
 )
 
 // JoinNetwork - helps a client join a network
-func JoinNetwork(cfg *config.ClientConfig, privateKey string, iscomms bool) error {
+func JoinNetwork(cfg *config.ClientConfig, privateKey string) error {
 	if cfg.Node.Network == "" {
 		return errors.New("no network provided")
 	}
@@ -102,7 +101,7 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string, iscomms bool) erro
 	// Find and set node MacAddress
 	if cfg.Node.MacAddress == "" {
 		macs, err := ncutils.GetMacAddr()
-		if err != nil || iscomms {
+		if err != nil {
 			//if macaddress can't be found set to random string
 			cfg.Node.MacAddress = ncutils.MakeRandomString(18)
 		} else {
@@ -123,45 +122,28 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string, iscomms bool) erro
 	}
 	// make sure name is appropriate, if not, give blank name
 	cfg.Node.Name = formatName(cfg.Node)
-	// differentiate between client/server here
-	var node = models.Node{
-		Password:   cfg.Node.Password,
-		Address:    cfg.Node.Address,
-		Address6:   cfg.Node.Address6,
-		ID:         cfg.Node.ID,
-		MacAddress: cfg.Node.MacAddress,
-		AccessKey:  cfg.Server.AccessKey,
-		IsStatic:   cfg.Node.IsStatic,
-		//Roaming:             cfg.Node.Roaming,
-		Network:             cfg.Network,
-		ListenPort:          cfg.Node.ListenPort,
-		PostUp:              cfg.Node.PostUp,
-		PostDown:            cfg.Node.PostDown,
-		PersistentKeepalive: cfg.Node.PersistentKeepalive,
-		LocalAddress:        cfg.Node.LocalAddress,
-		Interface:           cfg.Node.Interface,
-		PublicKey:           cfg.Node.PublicKey,
-		DNSOn:               cfg.Node.DNSOn,
-		Name:                cfg.Node.Name,
-		Endpoint:            cfg.Node.Endpoint,
-		UDPHolePunch:        cfg.Node.UDPHolePunch,
-		TrafficKeys:         cfg.Node.TrafficKeys,
-		OS:                  runtime.GOOS,
-		Version:             ncutils.Version,
-	}
-
-	logger.Log(0, "joining "+cfg.Network+" at "+cfg.Server.GRPCAddress)
-	var wcclient nodepb.NodeServiceClient
-
-	conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-		ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
-
+	cfg.Node.OS = runtime.GOOS
+	cfg.Node.Version = ncutils.Version
+	cfg.Node.AccessKey = cfg.Server.AccessKey
+	//not sure why this is needed ... setnode defaults should take care of this on server
+	cfg.Node.IPForwarding = "yes"
+	logger.Log(0, "joining "+cfg.Network+" at "+cfg.Server.API)
+	url := "https://" + cfg.Server.API + "/api/nodes/" + cfg.Network
+	response, err := API(cfg.Node, http.MethodPost, url, cfg.Server.AccessKey)
 	if err != nil {
-		log.Fatalf("Unable to establish client connection to "+cfg.Server.GRPCAddress+": %v", err)
+		return fmt.Errorf("error creating node %w", err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		bodybytes, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("error creating node %s %s", response.Status, string(bodybytes))
+	}
+	var node models.Node
+	if err := json.NewDecoder(response.Body).Decode(&node); err != nil {
+		//not sure the next line will work as response.Body probably needs to be reset before it can be read again
+		bodybytes, _ := ioutil.ReadAll(response.Body)
+		return fmt.Errorf("error decoding node from server %w %s", err, string(bodybytes))
 	}
-	defer conn.Close()
-	wcclient = nodepb.NewNodeServiceClient(conn)
-
 	// safety check. If returned node from server is local, but not currently configured as local, set to local addr
 	if cfg.Node.IsLocal != "yes" && node.IsLocal == "yes" && node.LocalRange != "" {
 		node.LocalAddress, err = ncutils.GetLocalIP(node.LocalRange)
@@ -186,35 +168,11 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string, iscomms bool) erro
 			return daemon.InstallDaemon(cfg)
 		}
 	}
-	data, err := json.Marshal(&node)
-	if err != nil {
-		return err
-	}
-	// Create node on server
-	res, err := wcclient.CreateNode(
-		context.TODO(),
-		&nodepb.Object{
-			Data: string(data),
-			Type: nodepb.NODE_TYPE,
-		},
-	)
-	if err != nil {
-		return err
-	}
 	logger.Log(1, "node created on remote server...updating configs")
-
 	// keep track of the old listenport value
 	oldListenPort := node.ListenPort
-
-	nodeData := res.Data
-	if err = json.Unmarshal([]byte(nodeData), &node); err != nil {
-		return err
-	}
-
 	cfg.Node = node
-
 	setListenPort(oldListenPort, cfg)
-
 	err = config.ModConfig(&cfg.Node)
 	if err != nil {
 		return err
@@ -223,45 +181,19 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string, iscomms bool) erro
 	if err = config.SaveBackup(node.Network); err != nil {
 		logger.Log(0, "failed to make backup, node will not auto restore if config is corrupted")
 	}
-
-	logger.Log(0, "retrieving peers")
-	peers, hasGateway, gateways, err := server.GetPeers(node.MacAddress, cfg.Network, cfg.Server.GRPCAddress, node.IsDualStack == "yes", node.IsIngressGateway == "yes", node.IsServer == "yes")
-	if err != nil && !ncutils.IsEmptyRecord(err) {
-		logger.Log(0, "failed to retrieve peers")
-		return err
-	}
-
 	logger.Log(0, "starting wireguard")
-	err = wireguard.InitWireguard(&node, privateKey, peers, hasGateway, gateways, false)
+	err = wireguard.InitWireguard(&node, privateKey, []wgtypes.PeerConfig{}, false)
 	if err != nil {
 		return err
 	}
-	//	if node.DNSOn == "yes" {
-	//		for _, server := range node.NetworkSettings.DefaultServerAddrs {
-	//			if server.IsLeader {
-	//				go func() {
-	//					if !local.SetDNSWithRetry(node, server.Address) {
-	//						cfg.Node.DNSOn = "no"
-	//						var currentCommsCfg = getCommsCfgByNode(&cfg.Node)
-	//						PublishNodeUpdate(&currentCommsCfg, &cfg)
-	//					}
-	//				}()
-	//				break
-	//			}
-	//		}
-	//	}
-
-	if !iscomms {
-		if cfg.Daemon != "off" {
-			err = daemon.InstallDaemon(cfg)
-		}
+	if cfg.Daemon != "off" {
+		err = daemon.InstallDaemon(cfg)
 		if err != nil {
 			return err
 		} else {
 			daemon.Restart()
 		}
 	}
-
 	return nil
 }
 

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)
 	}
@@ -84,56 +80,3 @@ 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
-}

netclient/functions/mqhandlers.go

@@ -202,10 +202,6 @@ func UpdatePeers(client mqtt.Client, msg mqtt.Message) {
 		return
 	}
 	logger.Log(0, "received peer update for node "+cfg.Node.Name+" "+cfg.Node.Network)
-	//skip dns updates if this is a peer update for comms network
-	if cfg.Node.NetworkSettings.IsComms == "yes" {
-		return
-	}
 	if cfg.Node.DNSOn == "yes" {
 		if err := setHostDNS(peerUpdate.DNS, cfg.Node.Network, ncutils.IsWindows()); err != nil {
 			logger.Log(0, "error updating /etc/hosts "+err.Error())

netclient/functions/mqpublish.go

@@ -18,7 +18,7 @@ import (
 
 // Checkin  -- go routine that checks for public or local ip changes, publishes changes
 //   if there are no updates, simply "pings" the server as a checkin
-func Checkin(ctx context.Context, wg *sync.WaitGroup, currentComms map[string]struct{}) {
+func Checkin(ctx context.Context, wg *sync.WaitGroup) {
 	defer wg.Done()
 	for {
 		select {
@@ -113,8 +113,7 @@ func Hello(nodeCfg *config.ClientConfig) {
 	logger.Log(3, "server checkin complete")
 }
 
-// requires the commscfg in which to send traffic over and nodecfg of node that is publish the message
-// node cfg is so that the traffic keys of that node may be fetched for encryption
+// node cfg is required  in order to fetch the traffic keys of that node for encryption
 func publish(nodeCfg *config.ClientConfig, dest string, msg []byte, qos byte) error {
 	// setup the keys
 	trafficPrivKey, err := auth.RetrieveTrafficKey(nodeCfg.Node.Network)

netclient/functions/pull.go

@@ -1,22 +1,20 @@
 package functions
 
 import (
-	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
 	"os"
 	"runtime"
 
-	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/local"
 	"github.com/gravitl/netmaker/netclient/ncutils"
 	"github.com/gravitl/netmaker/netclient/wireguard"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
 	//homedir "github.com/mitchellh/go-homedir"
 )
 
@@ -26,54 +24,31 @@ func Pull(network string, manual bool) (*models.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	node := cfg.Node
-	//servercfg := cfg.Server
-
 	if cfg.Node.IPForwarding == "yes" && !ncutils.IsWindows() {
 		if err = local.SetIPForwarding(); err != nil {
 			return nil, err
 		}
 	}
-	var resNode models.Node // just need to fill this with either server calls or client calls
-
-	var header metadata.MD
-	var wcclient nodepb.NodeServiceClient
-	var ctx context.Context
-
-	if cfg.Node.IsServer != "yes" {
-		conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-			ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
-		if err != nil {
-			logger.Log(1, "Cant dial GRPC server: ", err.Error())
-			return nil, err
-		}
-		defer conn.Close()
-		wcclient = nodepb.NewNodeServiceClient(conn)
-
-		ctx, err = auth.SetJWT(wcclient, network)
-		if err != nil {
-			logger.Log(1, "Failed to authenticate: ", err.Error())
-			return nil, err
-		}
-		data, err := json.Marshal(&node)
-		if err != nil {
-			logger.Log(1, "Failed to parse node config: ", err.Error())
-			return nil, err
-		}
-
-		req := &nodepb.Object{
-			Data: string(data),
-			Type: nodepb.NODE_TYPE,
-		}
-
-		readres, err := wcclient.ReadNode(ctx, req, grpc.Header(&header))
+	token, err := Authenticate(cfg)
+	if err != nil {
+		return nil, err
+	}
+	url := "https://" + cfg.Server.API + "/api/nodes/" + cfg.Network + "/" + cfg.Node.ID
+	response, err := API("", http.MethodGet, url, token)
+	if err != nil {
+		return nil, err
+	}
+	if response.StatusCode != http.StatusOK {
+		bytes, err := ioutil.ReadAll(response.Body)
 		if err != nil {
-			return nil, err
-		}
-
-		if err = json.Unmarshal([]byte(readres.Data), &resNode); err != nil {
-			return nil, err
+			fmt.Println(err)
 		}
+		return nil, (fmt.Errorf("%s %w", string(bytes), err))
+	}
+	defer response.Body.Close()
+	resNode := models.Node{}
+	if err := json.NewDecoder(response.Body).Decode(&resNode); err != nil {
+		return nil, fmt.Errorf("error decoding node %w", err)
 	}
 	// ensure that the OS never changes
 	resNode.OS = runtime.GOOS
@@ -90,25 +65,6 @@ func Pull(network string, manual bool) (*models.Node, error) {
 		if err = wireguard.SetWGConfig(network, false); err != nil {
 			return nil, err
 		}
-		nodeData, err := json.Marshal(&resNode)
-		if err != nil {
-			return &resNode, err
-		}
-
-		if resNode.IsServer != "yes" {
-			if wcclient == nil || ctx == nil {
-				return &cfg.Node, errors.New("issue initializing gRPC client")
-			}
-			req := &nodepb.Object{
-				Data:     string(nodeData),
-				Type:     nodepb.NODE_TYPE,
-				Metadata: "",
-			}
-			_, err = wcclient.UpdateNode(ctx, req, grpc.Header(&header))
-			if err != nil {
-				return &resNode, err
-			}
-		}
 	} else {
 		if err = wireguard.SetWGConfig(network, true); err != nil {
 			if errors.Is(err, os.ErrNotExist) && !ncutils.IsFreeBSD() {

netclient/functions/register.go

@@ -47,7 +47,7 @@ func Register(cfg *config.ClientConfig, key string) error {
 	} else if err != nil {
 		return err
 	}
-	return JoinNetwork(cfg, key, false)
+	return JoinNetwork(cfg, key)
 }
 
 // RegisterWithServer calls the register endpoint with privatekey and commonname - api returns ca and client certificate

netclient/ncutils/netclientutils.go

@@ -3,7 +3,6 @@ package ncutils
 import (
 	"bytes"
 	"crypto/rand"
-	"crypto/tls"
 	"encoding/gob"
 	"errors"
 	"fmt"
@@ -23,8 +22,6 @@ import (
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/models"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
 )
 
 // Version - version of the netclient
@@ -381,17 +378,6 @@ func GetWGPathSpecific() string {
 	}
 }
 
-// GRPCRequestOpts - gets grps request opts
-func GRPCRequestOpts(isSecure string) grpc.DialOption {
-	var requestOpts grpc.DialOption
-	requestOpts = grpc.WithInsecure()
-	if isSecure == "on" {
-		h2creds := credentials.NewTLS(&tls.Config{NextProtos: []string{"h2"}})
-		requestOpts = grpc.WithTransportCredentials(h2creds)
-	}
-	return requestOpts
-}
-
 // Copy - copies a src file to dest
 func Copy(src, dst string) error {
 	sourceFileStat, err := os.Stat(src)

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"
@@ -122,7 +121,7 @@ func SetPeers(iface string, node *models.Node, peers []wgtypes.PeerConfig) error
 }
 
 // Initializes a WireGuard interface
-func InitWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig, hasGateway bool, gateways []string, syncconf bool) error {
+func InitWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig, syncconf bool) error {
 
 	key, err := wgtypes.ParseKey(privkey)
 	if err != nil {
@@ -230,10 +229,6 @@ 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
-	}
 	privkey, err := RetrievePrivKey(network)
 	if err != nil {
 		return err
@@ -247,11 +242,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{}, true)
 	} else {
-		err = InitWireguard(&nodecfg, privkey, peers, hasGateway, gateways, false)
+		err = InitWireguard(&nodecfg, privkey, []wgtypes.PeerConfig{}, false)
 	}
 	if nodecfg.DNSOn == "yes" {
 		_ = local.UpdateDNS(nodecfg.Interface, nodecfg.Network, servercfg.CoreDNSAddr)

nginx/netmaker-nginx-template.conf

@@ -31,21 +31,4 @@ server {
         proxy_pass_request_headers      on;
         }
 }
-server {
-    listen 443 ssl http2;
-    server_name grpc.NETMAKER_BASE_DOMAIN;
-    ssl_certificate /etc/letsencrypt/live/NETMAKER_BASE_DOMAIN/fullchain.pem; 
-    ssl_certificate_key /etc/letsencrypt/live/NETMAKER_BASE_DOMAIN/privkey.pem; 
-    #include /etc/letsencrypt/options-ssl-nginx.conf; 
-    #ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; 
 
-        # Forces the header to be the one that is visible from the outside
-        proxy_set_header                Host api.NETMAKER_BASE_DOMAIN; # Please change to your URL
-
-        # Pass all headers through to the backend
-        proxy_pass_request_headers      on;
-
-        location / {
-            grpc_pass grpc://127.0.0.1:50051;
-        }
-}

scripts/install-netmaker.sh

@@ -34,7 +34,6 @@ echo "To Override, add a Wildcard (*.netmaker.example.com) DNS record pointing t
 echo "Or, add three DNS records pointing to $SERVER_PUBLIC_IP for the following (Replacing 'netmaker.example.com' with the domain of your choice):"
 echo "   dashboard.netmaker.example.com"
 echo "         api.netmaker.example.com"
-echo "        grpc.netmaker.example.com"
 echo "-----------------------------------------------------"
 read -p "Domain (Hit 'enter' to use $NETMAKER_BASE_DOMAIN): " domain
 read -p "Contact Email: " email

scripts/netmaker-server.sh

@@ -9,7 +9,6 @@ cat >/etc/netmaker/config/environments/dev.yaml<<EOL
 server:
   host:
   apiport: "8081"
-  grpcport: "50051"
   masterkey: "secretkey"
   allowedorigin: "*"
   restbackend: true            

scripts/token-convert.sh

@@ -7,8 +7,7 @@ token=$1
 token_json=$(echo $token | base64 -d)
 
 api_addr=$(echo $token_json | jq -r '.apiconn')
-grpc_addr=$(echo $token_json | jq -r '.grpcconn')
 network=$(echo $token_json | jq -r '.network')
 key=$(echo $token_json | jq -r '.key')
 
-echo ./netclient join -k $key -n $network --apiserver $api_addr --grpcserver $grpc_addr
+echo ./netclient join -k $key -n $network --apiserver $api_addr 

servercfg/serverconf.go

@@ -2,23 +2,17 @@ package servercfg
 
 import (
 	"errors"
-	"fmt"
 	"io"
-	"math/rand"
-	"net"
 	"net/http"
 	"os"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/gravitl/netmaker/config"
-	"github.com/gravitl/netmaker/logger"
 )
 
 var (
 	Version = "dev"
-	commsID = ""
 )
 
 // SetHost - sets the host ip
@@ -40,9 +34,6 @@ func GetServerConfig() config.ServerConfig {
 	cfg.APIPort = GetAPIPort()
 	cfg.APIPort = GetAPIPort()
 	cfg.MQPort = GetMQPort()
-	cfg.GRPCHost = GetGRPCHost()
-	cfg.GRPCPort = GetGRPCPort()
-	cfg.GRPCConnString = GetGRPCConnString()
 	cfg.MasterKey = "(hidden)"
 	cfg.DNSKey = "(hidden)"
 	cfg.AllowedOrigin = GetAllowedOrigin()
@@ -68,10 +59,6 @@ func GetServerConfig() config.ServerConfig {
 	if IsDisplayKeys() {
 		cfg.DisplayKeys = "on"
 	}
-	cfg.GRPCSSL = "off"
-	if IsGRPCSSL() {
-		cfg.GRPCSSL = "on"
-	}
 	cfg.DisableRemoteIPCheck = "off"
 	if DisableRemoteIPCheck() {
 		cfg.DisableRemoteIPCheck = "on"
@@ -97,6 +84,7 @@ func GetServerConfig() config.ServerConfig {
 	services := strings.Join(GetPortForwardServiceList(), ",")
 	cfg.PortForwardServices = services
 	cfg.Server = GetServer()
+	cfg.Verbosity = GetVerbosity()
 
 	return cfg
 }
@@ -195,59 +183,17 @@ func GetDefaultNodeLimit() int32 {
 	return limit
 }
 
-// GetGRPCConnString - get grpc conn string
-func GetGRPCConnString() string {
-	conn := ""
-	if os.Getenv("SERVER_GRPC_CONN_STRING") != "" {
-		conn = os.Getenv("SERVER_GRPC_CONN_STRING")
-	} else if config.Config.Server.GRPCConnString != "" {
-		conn = config.Config.Server.GRPCConnString
-	} else {
-		conn = GetGRPCHost() + ":" + GetGRPCPort()
-	}
-	return conn
-}
-
 // GetCoreDNSAddr - gets the core dns address
 func GetCoreDNSAddr() string {
 	addr, _ := GetPublicIP()
 	if os.Getenv("COREDNS_ADDR") != "" {
 		addr = os.Getenv("COREDNS_ADDR")
 	} else if config.Config.Server.CoreDNSAddr != "" {
-		addr = config.Config.Server.GRPCConnString
+		addr = config.Config.Server.CoreDNSAddr
 	}
 	return addr
 }
 
-// GetGRPCHost - get the grpc host url
-func GetGRPCHost() string {
-	serverhost := "127.0.0.1"
-	remoteip, _ := GetPublicIP()
-	if os.Getenv("SERVER_GRPC_HOST") != "" {
-		serverhost = os.Getenv("SERVER_GRPC_HOST")
-	} else if config.Config.Server.GRPCHost != "" {
-		serverhost = config.Config.Server.GRPCHost
-	} else if os.Getenv("SERVER_HOST") != "" {
-		serverhost = os.Getenv("SERVER_HOST")
-	} else {
-		if remoteip != "" {
-			serverhost = remoteip
-		}
-	}
-	return serverhost
-}
-
-// GetGRPCPort - gets the grpc port
-func GetGRPCPort() string {
-	grpcport := "50051"
-	if os.Getenv("GRPC_PORT") != "" {
-		grpcport = os.Getenv("GRPC_PORT")
-	} else if config.Config.Server.GRPCPort != "" {
-		grpcport = config.Config.Server.GRPCPort
-	}
-	return grpcport
-}
-
 // GetMQPort - gets the mq port
 func GetMQPort() string {
 	mqport := "1883"
@@ -259,33 +205,6 @@ func GetMQPort() string {
 	return mqport
 }
 
-// GetGRPCPort - gets the grpc port
-func GetCommsCIDR() string {
-	netrange := "172.16.0.0/16"
-	if os.Getenv("COMMS_CIDR") != "" {
-		netrange = os.Getenv("COMMS_CIDR")
-	} else if config.Config.Server.CommsCIDR != "" {
-		netrange = config.Config.Server.CommsCIDR
-	} else { // make a random one, which should only affect initialize first time, unless db is removed
-		netrange = genNewCommsCIDR()
-	}
-	_, _, err := net.ParseCIDR(netrange)
-	if err == nil {
-		return netrange
-	}
-	return "172.16.0.0/16"
-}
-
-// GetCommsID - gets the grpc port
-func GetCommsID() string {
-	return commsID
-}
-
-// SetCommsID - sets the commsID
-func SetCommsID(newCommsID string) {
-	commsID = newCommsID
-}
-
 // GetMessageQueueEndpoint - gets the message queue endpoint
 func GetMessageQueueEndpoint() string {
 	host, _ := GetPublicIP()
@@ -423,6 +342,23 @@ func GetServer() string {
 	return server
 }
 
+func GetVerbosity() int32 {
+	var verbosity = 0
+	var err error
+	if os.Getenv("VERBOSITY") != "" {
+		verbosity, err = strconv.Atoi(os.Getenv("VERBOSITY"))
+		if err != nil {
+			verbosity = 0
+		}
+	} else if config.Config.Server.Verbosity != 0 {
+		verbosity = int(config.Config.Server.Verbosity)
+	}
+	if verbosity < 0 || verbosity > 3 {
+		verbosity = 0
+	}
+	return int32(verbosity)
+}
+
 // IsDNSMode - should it run with DNS
 func IsDNSMode() bool {
 	isdns := true
@@ -453,21 +389,6 @@ func IsDisplayKeys() bool {
 	return isdisplay
 }
 
-// IsGRPCSSL - ssl grpc on or off
-func IsGRPCSSL() bool {
-	isssl := false
-	if os.Getenv("GRPC_SSL") != "" {
-		if os.Getenv("GRPC_SSL") == "on" {
-			isssl = true
-		}
-	} else if config.Config.Server.GRPCSSL != "" {
-		if config.Config.Server.GRPCSSL == "on" {
-			isssl = true
-		}
-	}
-	return isssl
-}
-
 // DisableRemoteIPCheck - disable the remote ip check
 func DisableRemoteIPCheck() bool {
 	disabled := false
@@ -630,34 +551,3 @@ func GetRce() bool {
 func GetDebug() bool {
 	return os.Getenv("DEBUG") == "on" || config.Config.Server.Debug == true
 }
-
-func genNewCommsCIDR() string {
-	currIfaces, err := net.Interfaces()
-	netrange := fmt.Sprintf("172.%d.0.0/16", genCommsByte())
-	if err == nil { // make sure chosen CIDR doesn't overlap with any local iface CIDRs
-		iter := 0
-		for i := 0; i < len(currIfaces); i++ {
-			if currentAddrs, err := currIfaces[i].Addrs(); err == nil {
-				for j := range currentAddrs {
-					if strings.Contains(currentAddrs[j].String(), netrange[0:7]) {
-						if iter > 20 { // if this hits, then the cidr should be specified
-							logger.FatalLog("could not find a suitable comms network on this server, please manually enter one")
-						}
-						netrange = fmt.Sprintf("172.%d.0.0/16", genCommsByte())
-						i = -1 // reset to loop back through
-						iter++ // track how many times you've iterated and not found one
-						break
-					}
-				}
-			}
-		}
-	}
-	return netrange
-}
-
-func genCommsByte() int {
-	const min = 1 << 4 // 16
-	const max = 1 << 5 // 32
-	rand.Seed(time.Now().UnixNano())
-	return rand.Intn(max-min) + min
-}

serverctl/serverctl.go

@@ -5,83 +5,21 @@ import (
 	"net"
 	"os"
 	"strings"
-	"time"
 
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/logic/acls"
 	"github.com/gravitl/netmaker/logic/acls/nodeacls"
-	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/netclient/ncutils"
 	"github.com/gravitl/netmaker/servercfg"
 )
 
-// COMMS_NETID - name of the comms network
-var COMMS_NETID string
-
 const (
 	// NETMAKER_BINARY_NAME - name of netmaker binary
 	NETMAKER_BINARY_NAME = "netmaker"
 )
 
-// InitializeCommsNetwork - Check if comms network exists (for MQ, DNS, SSH traffic), if not, create
-func InitializeCommsNetwork() error {
-
-	setCommsID()
-
-	commsNetwork, err := logic.GetNetwork(COMMS_NETID)
-	if err != nil {
-		var network models.Network
-		network.NetID = COMMS_NETID
-		network.AddressRange = servercfg.GetCommsCIDR()
-		network.IsPointToSite = "yes"
-		network.DefaultUDPHolePunch = "yes"
-		network.IsComms = "yes"
-		logger.Log(1, "comms net does not exist, creating with ID,", network.NetID, "and CIDR,", network.AddressRange)
-		_, err = logic.CreateNetwork(network)
-		return err
-	} else if commsNetwork.DefaultACL == "" {
-		commsNetwork.DefaultACL = "yes"
-		if err = logic.SaveNetwork(&commsNetwork); err != nil {
-			logger.Log(1, "comms net default acl is set incorrectly, please manually adjust to \"yes\",", COMMS_NETID)
-		}
-	}
-	// gracefully check for comms interface
-	gracefulCommsWait()
-
-	return nil
-}
-
-func gracefulCommsWait() {
-	output, _ := ncutils.RunCmd("wg", false)
-	starttime := time.Now()
-	ifaceReady := strings.Contains(output, COMMS_NETID)
-	for !ifaceReady && !(time.Now().After(starttime.Add(time.Second << 4))) {
-		output, _ = ncutils.RunCmd("wg", false)
-		SyncServerNetwork(COMMS_NETID)
-		time.Sleep(time.Second)
-		ifaceReady = strings.Contains(output, COMMS_NETID)
-	}
-	logger.Log(1, "comms network", COMMS_NETID, "ready")
-}
-
-// SetJWTSecret - sets the jwt secret on server startup
-func setCommsID() {
-	currentid, idErr := logic.FetchCommsNetID()
-	if idErr != nil {
-		commsid := logic.RandomString(8)
-		if err := logic.StoreCommsNetID(commsid); err != nil {
-			logger.FatalLog("something went wrong when configuring comms id")
-		}
-		COMMS_NETID = commsid
-		servercfg.SetCommsID(COMMS_NETID)
-		return
-	}
-	COMMS_NETID = currentid
-	servercfg.SetCommsID(COMMS_NETID)
-}
-
 // InitServerNetclient - intializes the server netclient
 // 1. Check if config directory exists, if not attempt to make
 // 2. Check current networks and run pull to get interface up to date in case of restart

test/config/environments/dev.yaml

@@ -1,7 +1,6 @@
 server:
   host: "localhost"
   apiport: "8081"
-  grpcport: "50051"
   masterkey: "secretkey"
   allowedorigin: "*"
   restbackend: true            

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)
+}