ripping out wg grpc stuff

config/config.go

@@ -30,7 +30,6 @@ var Config *EnvironmentConfig
 // EnvironmentConfig :
 type EnvironmentConfig struct {
 	Server ServerConfig `yaml:"server"`
-	WG     WG           `yaml:"wg"`
 }
 
 // ServerConfig :
@@ -56,17 +55,6 @@ type ServerConfig struct {
 	Verbosity            int32  `yaml:"verbosity"`
 }
 
-type WG struct {
-	RegisterKeyRequired string `yaml:"keyrequired"`
-	GRPCWireGuard       string `yaml:"grpcwg"`
-	GRPCWGInterface     string `yaml:"grpciface"`
-	GRPCWGAddress       string `yaml:"grpcaddr"`
-	GRPCWGAddressRange  string `yaml:"grpcaddrrange"`
-	GRPCWGPort          string `yaml:"grpcport"`
-	GRPCWGPubKey        string `yaml:"pubkey"`
-	GRPCWGPrivKey       string `yaml:"privkey"`
-}
-
 //reading in the env file
 func readConfig() *EnvironmentConfig {
 	file := fmt.Sprintf("config/environments/%s.yaml", getEnv())

config/environments/dev.yaml

@@ -9,14 +9,4 @@ server:
   agentbackend: "" # defaults to "on" or AGENT_BACKEND (if set)
   clientmode: "" # defaults to "on" or CLIENT_MODE (if set)
   dnsmode: "" # defaults to "on" or DNS_MODE (if set)
-  disableremoteipcheck: "" # defaults to "false" or DISABLE_REMOTE_IP_CHECK (if set)
-wg:
-  keyrequired: "" # defaults to "". If set to "yes", a key is required for signing up for the comms network 
-  grpcwg: "" # defaults to "on" or SERVER_GRPC_WIREGUARD if set
-  grpciface: "" # defaults to nm-grpc-wg or SERVER_GRPC_WG_INTERFACE if set
-  grpcaddr: "" # defaults to 10.101.0.1 or SERVER_GRPC_WG_ADDRESS if set
-  grpcaddrrange: "" # defaults to 10.101.0.0/16 or SERVER_GRPC_WG_ADDRESS_RANGE if set
-  grpcendpoint: "" # defaults to SERVER_HOST if unset
-  grpcport: "" # defaults to 50555 or SERVER_GRPC_WG_PORT if set
-  pubkey: "" # defaults to generated value or SERVER_GRPC_WG_PUBKEY if set
-  privkey: "" # defaults to generated value or SERVER_GRPC_WG_PRIVKEY if set
+  disableremoteipcheck: "" # defaults to "false" or DISABLE_REMOTE_IP_CHECK (if set)

controllers/config/environments/dev.yaml

@@ -2,16 +2,10 @@ server:
   host: "localhost"
   apiport: "8081"
   grpcport: "50051"
-  masterkey: "secretkey"
+  masterkey: ""
   allowedorigin: "*"
   restbackend: true            
   agentbackend: true
   defaultnetname: "default"
   defaultnetrange: "10.10.10.0/24"
-  createdefault: true
-mongoconn:
-  user: "mongoadmin"
-  pass: "mongopass"
-  host: "localhost"
-  port: "27017"
-  opts: '/?authSource=admin'
+  createdefault: true

controllers/controller.go

@@ -30,8 +30,7 @@ func HandleRESTRequests(wg *sync.WaitGroup) {
 	fileHandlers(r)
 	serverHandlers(r)
 	extClientHandlers(r)
-	intClientHandlers(r)
-
+	
 	port := servercfg.GetAPIPort()
 
 	srv := &http.Server{Addr: ":" + port, Handler: handlers.CORS(originsOk, headersOk, methodsOk)(r)}

controllers/intClientHttpController.go

@@ -1,205 +0,0 @@
-package controller
-
-import (
-	//	"fmt"
-	// "github.com/davecgh/go-spew/spew"
-
-	"encoding/json"
-	"errors"
-	"net/http"
-
-	"github.com/gorilla/mux"
-	"github.com/gravitl/netmaker/database"
-	"github.com/gravitl/netmaker/functions"
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/servercfg"
-	"github.com/gravitl/netmaker/serverctl"
-	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
-)
-
-func intClientHandlers(r *mux.Router) {
-
-	r.HandleFunc("/api/intclient/{clientid}", securityCheck(false, http.HandlerFunc(getIntClient))).Methods("GET")
-	r.HandleFunc("/api/intclients", securityCheck(false, http.HandlerFunc(getAllIntClients))).Methods("GET")
-	r.HandleFunc("/api/intclients/deleteall", securityCheck(false, http.HandlerFunc(deleteAllIntClients))).Methods("DELETE")
-	r.HandleFunc("/api/intclient/{clientid}", securityCheck(false, http.HandlerFunc(updateIntClient))).Methods("PUT")
-	r.HandleFunc("/api/intclient/register", http.HandlerFunc(registerIntClient)).Methods("POST")
-	r.HandleFunc("/api/intclient/{clientid}", http.HandlerFunc(deleteIntClient)).Methods("DELETE")
-}
-
-func getAllIntClients(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	clients, err := functions.GetAllIntClients()
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-	//Return all the extclients in JSON format
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(clients)
-}
-
-func deleteAllIntClients(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	err := functions.DeleteAllIntClients()
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-	w.WriteHeader(http.StatusOK)
-}
-
-func deleteIntClient(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	// get params
-	var params = mux.Vars(r)
-
-	success, err := DeleteIntClient(params["clientid"])
-
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	} else if !success {
-		err = errors.New("Could not delete intclient " + params["clientid"])
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-	returnSuccessResponse(w, r, params["clientid"]+" deleted.")
-}
-
-func getIntClient(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	var params = mux.Vars(r)
-
-	client, err := GetIntClient(params["clientid"])
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(client)
-}
-
-func updateIntClient(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-
-	var errorResponse = models.ErrorResponse{
-		Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
-	}
-
-	var clientreq models.IntClient
-
-	//get node from body of request
-	err := json.NewDecoder(r.Body).Decode(&clientreq)
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-	if servercfg.IsRegisterKeyRequired() {
-		validKey := functions.IsKeyValidGlobal(clientreq.AccessKey)
-		if !validKey {
-			errorResponse = models.ErrorResponse{
-				Code: http.StatusUnauthorized, Message: "W1R3: Key invalid, or none provided.",
-			}
-			returnErrorResponse(w, r, errorResponse)
-			return
-		}
-	}
-	client, err := RegisterIntClient(clientreq)
-
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(client)
-}
-
-func RegisterIntClient(client models.IntClient) (models.IntClient, error) {
-	if client.PrivateKey == "" {
-		privateKey, err := wgtypes.GeneratePrivateKey()
-		if err != nil {
-			return client, err
-		}
-
-		client.PrivateKey = privateKey.String()
-		client.PublicKey = privateKey.PublicKey().String()
-	}
-
-	if client.Address == "" {
-		newAddress, err := functions.UniqueAddress(client.Network)
-		if err != nil {
-			return client, err
-		}
-		if newAddress == "" {
-			return client, errors.New("Could not find an address.")
-		}
-		client.Address = newAddress
-	}
-	if client.Network == "" {
-		client.Network = "comms"
-	}
-	server, err := serverctl.GetServerWGConf()
-	//spew.Dump(server)
-	if err != nil {
-		return client, err
-	}
-	client.ServerPublicEndpoint = server.ServerPublicEndpoint
-	client.ServerAPIPort = server.ServerAPIPort
-	client.ServerPrivateAddress = server.ServerPrivateAddress
-	client.ServerWGPort = server.ServerWGPort
-	client.ServerGRPCPort = server.ServerGRPCPort
-	client.ServerKey = server.ServerKey
-
-	if client.ClientID == "" {
-		clientid := StringWithCharset(7, charset)
-		clientname := "client-" + clientid
-		client.ClientID = clientname
-	}
-
-	data, err := json.Marshal(&client)
-	if err != nil {
-		return client, err
-	}
-	if err = database.Insert(client.ClientID, string(data), database.INT_CLIENTS_TABLE_NAME); err != nil {
-		return client, err
-	}
-
-	err = serverctl.ReconfigureServerWireGuard()
-
-	return client, err
-}
-func registerIntClient(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-
-	var errorResponse = models.ErrorResponse{
-		Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
-	}
-
-	var clientreq models.IntClient
-
-	//get node from body of request
-	err := json.NewDecoder(r.Body).Decode(&clientreq)
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-	if servercfg.IsRegisterKeyRequired() {
-		validKey := functions.IsKeyValidGlobal(clientreq.AccessKey)
-		if !validKey {
-			errorResponse = models.ErrorResponse{
-				Code: http.StatusUnauthorized, Message: "W1R3: Key invalid, or none provided.",
-			}
-			returnErrorResponse(w, r, errorResponse)
-			return
-		}
-	}
-	client, err := RegisterIntClient(clientreq)
-
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(client)
-}

controllers/networkHttpController.go

@@ -417,9 +417,6 @@ func CreateNetwork(network models.Network) error {
 }
 
 // BEGIN KEY MANAGEMENT SECTION
-
-//TODO: Very little error handling
-//accesskey is created as a json string inside the Network collection item in mongo
 func createAccessKey(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
@@ -479,7 +476,6 @@ func CreateAccessKey(accesskey models.AccessKey, network models.Network) (models
 
 	var accessToken models.AccessToken
 	s := servercfg.GetServerConfig()
-	w := servercfg.GetWGConfig()
 	servervals := models.ServerConfig{
 		CoreDNSAddr:    s.CoreDNSAddr,
 		APIConnString:  s.APIConnString,
@@ -490,16 +486,7 @@ func CreateAccessKey(accesskey models.AccessKey, network models.Network) (models
 		GRPCPort:       s.GRPCPort,
 		GRPCSSL:        s.GRPCSSL,
 	}
-	wgvals := models.WG{
-		GRPCWireGuard:  w.GRPCWireGuard,
-		GRPCWGAddress:  w.GRPCWGAddress,
-		GRPCWGPort:     w.GRPCWGPort,
-		GRPCWGPubKey:   w.GRPCWGPubKey,
-		GRPCWGEndpoint: s.APIHost,
-	}
-
 	accessToken.ServerConfig = servervals
-	accessToken.WG = wgvals
 	accessToken.ClientConfig.Network = netID
 	accessToken.ClientConfig.Key = accesskey.Value
 	accessToken.ClientConfig.LocalRange = privAddr
@@ -538,7 +525,6 @@ func GetSignupToken(netID string) (models.AccessKey, error) {
 	var accesskey models.AccessKey
 	var accessToken models.AccessToken
 	s := servercfg.GetServerConfig()
-	w := servercfg.GetWGConfig()
 	servervals := models.ServerConfig{
 		APIConnString:  s.APIConnString,
 		APIHost:        s.APIHost,
@@ -548,16 +534,7 @@ func GetSignupToken(netID string) (models.AccessKey, error) {
 		GRPCPort:       s.GRPCPort,
 		GRPCSSL:        s.GRPCSSL,
 	}
-	wgvals := models.WG{
-		GRPCWireGuard:  w.GRPCWireGuard,
-		GRPCWGAddress:  w.GRPCWGAddress,
-		GRPCWGPort:     w.GRPCWGPort,
-		GRPCWGPubKey:   w.GRPCWGPubKey,
-		GRPCWGEndpoint: s.APIHost,
-	}
-
 	accessToken.ServerConfig = servervals
-	accessToken.WG = wgvals
 
 	tokenjson, err := json.Marshal(accessToken)
 	if err != nil {

controllers/serverHttpController.go

@@ -14,7 +14,6 @@ import (
 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/getwgconfig", securityCheckServer(true, http.HandlerFunc(getWGConfig))).Methods("GET")
     r.HandleFunc("/api/server/removenetwork/{network}", securityCheckServer(true, http.HandlerFunc(removeNetwork))).Methods("DELETE")
 }
 
@@ -91,17 +90,6 @@ func getConfig(w http.ResponseWriter, r *http.Request) {
         json.NewEncoder(w).Encode(scfg)
 }
 
-func getWGConfig(w http.ResponseWriter, r *http.Request) {
-        // Set header
-        w.Header().Set("Content-Type", "application/json")
-
-        // get params
-
-        wgcfg := servercfg.GetWGConfig()
-        w.WriteHeader(http.StatusOK)
-        json.NewEncoder(w).Encode(wgcfg)
-}
-
 /*
 func getMongoConfig(w http.ResponseWriter, r *http.Request) {
         // Set header

netclient/command/commands.go

@@ -124,10 +124,5 @@ func List(cfg config.ClientConfig) error {
 func Uninstall(cfg config.GlobalConfig) error {
 	log.Println("Uninstalling netclient")
 	err := functions.Uninstall()
-	err = functions.Unregister(cfg)
-	return err
-}
-func Unregister(cfg config.GlobalConfig) error {
-	err := functions.Unregister(cfg)
 	return err
 }

netclient/functions/register.go

@@ -1,101 +0,0 @@
-package functions
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"io/ioutil"
-	"log"
-	"net"
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/netclient/config"
-	"github.com/gravitl/netmaker/netclient/local"
-	//	"github.com/davecgh/go-spew/spew"
-)
-
-func Register(cfg config.GlobalConfig) error {
-
-	_, err := os.Stat("/etc/netclient")
-	if os.IsNotExist(err) {
-		os.Mkdir("/etc/netclient", 744)
-	} else if err != nil {
-		log.Println("couldnt find or create /etc/netclient")
-		return err
-	}
-
-	postclient := &models.IntClient{
-		AccessKey:  cfg.Client.AccessKey,
-		PublicKey:  cfg.Client.PublicKey,
-		PrivateKey: cfg.Client.PublicKey,
-		Address:    cfg.Client.Address,
-		Address6:   cfg.Client.Address6,
-		Network:    "comms",
-	}
-
-	jsonstring, err := json.Marshal(postclient)
-	if err != nil {
-		return err
-	}
-	jsonbytes := []byte(jsonstring)
-	body := bytes.NewBuffer(jsonbytes)
-	publicaddress := net.JoinHostPort(cfg.Client.ServerPublicEndpoint, cfg.Client.ServerAPIPort)
-
-	res, err := http.Post("http://"+publicaddress+"/api/intclient/register", "application/json", body)
-	if err != nil {
-		log.Println("Failed to register to http://" + publicaddress + "/api/client/register")
-		return err
-	}
-	if res.StatusCode != http.StatusOK {
-		log.Println("Failed to register to http://" + publicaddress + "/api/client/register")
-		return errors.New("request to server failed: " + res.Status)
-	}
-	bodyBytes, err := ioutil.ReadAll(res.Body)
-	//bodyString := string(bodyBytes)
-	//spew.Dump(bodyString)
-	if err != nil {
-		return err
-	}
-	var wgclient models.IntClient
-	json.Unmarshal(bodyBytes, &wgclient)
-	//spew.Dump(wgclient)
-	err = config.ModGlobalConfig(wgclient)
-	if err != nil {
-		return err
-	}
-	//spew.Dump(wgclient)
-	// err = wireguard.InitGRPCWireguard(wgclient)
-	//     if err != nil {
-	//             return err
-	//     }
-	log.Println("registered netclient to " + cfg.Client.ServerPrivateAddress)
-	return err
-}
-
-func Unregister(cfg config.GlobalConfig) error {
-	client := &http.Client{Timeout: 7 * time.Second}
-	publicaddress := net.JoinHostPort(cfg.Client.ServerPublicEndpoint, cfg.Client.ServerAPIPort)
-	log.Println("sending delete request to: " + "http://" + publicaddress + "/api/intclient/" + cfg.Client.ClientID)
-	req, err := http.NewRequest("DELETE", "http://"+publicaddress+"/api/intclient/"+cfg.Client.ClientID, nil)
-	if err != nil {
-		log.Println(err)
-	} else {
-		res, err := client.Do(req)
-		if res == nil {
-			err = errors.New("server not reachable at " + "http://" + publicaddress + "/api/intclient/" + cfg.Client.ClientID)
-			log.Println(err)
-		} else if res.StatusCode != http.StatusOK {
-			err = errors.New("request to server failed: " + res.Status)
-			log.Println(err)
-			defer res.Body.Close()
-		}
-	}
-	err = local.WipeGRPCClient()
-	if err == nil {
-		log.Println("successfully removed grpc client interface")
-	}
-	return err
-}

netclient/main.go

@@ -316,23 +316,6 @@ func main() {
 				return err
 			},
 		},
-		{
-			Name:  "unregister",
-			Usage: "Unregister the netclient from secure server GRPC.",
-			Flags: cliFlags,
-			// the action, or code that will be executed when
-			// we execute our `ns` command
-			Action: func(c *cli.Context) error {
-				cfg, err := config.ReadGlobalConfig()
-				if err != nil {
-					return err
-				}
-				var gconf config.GlobalConfig
-				gconf = *cfg
-				err = command.Unregister(gconf)
-				return err
-			},
-		},
 	}
 
 	// start our application

servercfg/serverconf.go

@@ -60,22 +60,6 @@ func GetServerConfig() config.ServerConfig {
 	}
 	return cfg
 }
-
-func GetWGConfig() config.WG {
-	var cfg config.WG
-	if IsGRPCWireGuard() {
-		cfg.GRPCWireGuard = "on"
-	} else {
-		cfg.GRPCWireGuard = "off"
-	}
-	cfg.GRPCWGInterface = GetGRPCWGInterface()
-	cfg.GRPCWGAddress = GetGRPCWGAddress()
-	cfg.GRPCWGAddressRange = GetGRPCWGAddressRange()
-	cfg.GRPCWGPort = GetGRPCWGPort()
-	cfg.GRPCWGPubKey = GetGRPCWGPubKey()
-	cfg.GRPCWGPrivKey = GetGRPCWGPrivKey()
-	return cfg
-}
 func GetAPIConnString() string {
 	conn := ""
 	if os.Getenv("SERVER_API_CONN_STRING") != "" {
@@ -145,19 +129,15 @@ func GetCoreDNSAddr() string {
 func GetGRPCHost() string {
 	serverhost := "127.0.0.1"
 	remoteip, _ := GetPublicIP()
-	if IsGRPCWireGuard() {
-		serverhost = GetGRPCWGAddress()
+	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 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
-			}
+		if remoteip != "" {
+			serverhost = remoteip
 		}
 	}
 	return serverhost

servercfg/wireguardconf.go

@@ -1,85 +0,0 @@
-package servercfg
-
-import (
-        "github.com/gravitl/netmaker/config"
-        "os"
-)
-func IsRegisterKeyRequired() bool {
-       isrequired := false
-       if os.Getenv("SERVER_GRPC_WG_KEYREQUIRED") != "" {
-                if os.Getenv("SERVER_GRPC_WG_KEYREQUIRED") == "yes" {
-                        isrequired = true
-                }
-       } else if config.Config.WG.RegisterKeyRequired != "" {
-                if config.Config.WG.RegisterKeyRequired == "yes" {
-                        isrequired = true
-                }
-       }
-       return isrequired
-}
-func IsGRPCWireGuard() bool {
-       iswg := true
-       if os.Getenv("SERVER_GRPC_WIREGUARD") != "" {
-                if os.Getenv("SERVER_GRPC_WIREGUARD") == "off" {
-                        iswg = false
-                }
-       } else if config.Config.WG.GRPCWireGuard != "" {
-                if config.Config.WG.GRPCWireGuard == "off" {
-                        iswg = false
-                }
-       }
-       return iswg
-}
-func GetGRPCWGInterface() string {
-       iface := "nm-grpc-wg"
-       if os.Getenv("SERVER_GRPC_WG_INTERFACE") != "" {
-                iface = os.Getenv("SERVER_GRPC_WG_INTERFACE")
-       } else if config.Config.WG.GRPCWGInterface != "" {
-                iface = config.Config.WG.GRPCWGInterface
-       }
-       return iface
-}
-func GetGRPCWGAddress() string {
-      address := "10.101.0.1"
-      if os.Getenv("SERVER_GRPC_WG_ADDRESS") != ""  {
-              address = os.Getenv("SERVER_GRPC_WG_ADDRESS")
-      } else if config.Config.WG.GRPCWGAddress != "" {
-              address = config.Config.WG.GRPCWGAddress
-      }
-      return address
-}
-func GetGRPCWGAddressRange() string {
-      address := "10.101.0.0/16"
-      if os.Getenv("SERVER_GRPC_WG_ADDRESS_RANGE") != ""  {
-              address = os.Getenv("SERVER_GRPC_WG_ADDRESS_RANGE")
-      } else if config.Config.WG.GRPCWGAddressRange != "" {
-              address = config.Config.WG.GRPCWGAddressRange
-      }
-      return address
-}
-func GetGRPCWGPort() string {
-      port := "50555"
-      if os.Getenv("SERVER_GRPC_WG_PORT") != ""  {
-              port = os.Getenv("SERVER_GRPC_WG_PORT")
-      } else if config.Config.WG.GRPCWGPort != "" {
-              port = config.Config.WG.GRPCWGPort
-      }
-      return port
-}
-
-func GetGRPCWGPubKey() string {
-      key := os.Getenv("SERVER_GRPC_WG_PUBKEY")
-      if config.Config.WG.GRPCWGPubKey != "" {
-              key = config.Config.WG.GRPCWGPubKey
-      }
-      return key
-}
-
-func GetGRPCWGPrivKey() string {
-      key := os.Getenv("SERVER_GRPC_WG_PRIVKEY")
-      if config.Config.WG.GRPCWGPrivKey != "" {
-              key = config.Config.WG.GRPCWGPrivKey
-      }
-      return key
-}
-

serverctl/serverctl.go

@@ -7,8 +7,6 @@ import (
 	"log"
 	"os"
 	"os/exec"
-	"time"
-
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/functions"
 	"github.com/gravitl/netmaker/models"
@@ -31,43 +29,6 @@ func GetServerWGConf() (models.IntClient, error) {
 	return models.IntClient{}, errors.New("could not find comms server")
 }
 
-func CreateCommsNetwork() (bool, error) {
-
-	iscreated := false
-	exists, err := functions.NetworkExists("comms")
-
-	if exists || err != nil {
-		log.Println("comms network already exists. Skipping...")
-		return true, err
-	} else {
-		var network models.Network
-
-		network.NetID = "comms"
-		network.IsIPv6 = "no"
-		network.IsIPv4 = "yes"
-		network.IsGRPCHub = "yes"
-		network.AddressRange = servercfg.GetGRPCWGAddressRange()
-		network.DisplayName = "comms"
-		network.SetDefaults()
-		network.SetNodesLastModified()
-		network.SetNetworkLastModified()
-		network.KeyUpdateTimeStamp = time.Now().Unix()
-		network.IsLocal = "no"
-		network.KeyUpdateTimeStamp = time.Now().Unix()
-
-		log.Println("Creating comms network...")
-		value, err := json.Marshal(network)
-		if err != nil {
-			return false, err
-		}
-		database.Insert(network.NetID, string(value), database.NETWORKS_TABLE_NAME)
-	}
-	if err == nil {
-		iscreated = true
-	}
-	return iscreated, err
-}
-
 func InstallNetclient() error {
 	if !FileExists("/etc/netclient/netclient") {
 		_, err := copy("./netclient/netclient", "/etc/netclient/netclient")

serverctl/wireguard.go

@@ -1,189 +1,10 @@
 package serverctl
 
 import (
-	//"github.com/davecgh/go-spew/spew"
-
-	"encoding/json"
-	"errors"
-	"log"
-	"net"
-	"os"
-	"strconv"
-
-	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/functions"
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/servercfg"
-	"github.com/vishvananda/netlink"
 	"golang.zx2c4.com/wireguard/wgctrl"
-	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
-func InitServerWireGuard() error {
-
-	created, err := CreateCommsNetwork()
-	if !created {
-		return err
-	}
-	wgconfig := servercfg.GetWGConfig()
-	if !(wgconfig.GRPCWireGuard == "on") {
-		return errors.New("WireGuard not enabled on this server.")
-	}
-	ifaceSettings := netlink.NewLinkAttrs()
-
-	if wgconfig.GRPCWGInterface == "" {
-		return errors.New("No WireGuard Interface Name set.")
-	}
-	ifaceSettings.Name = wgconfig.GRPCWGInterface
-	wglink := &models.WireGuardLink{LinkAttrs: &ifaceSettings}
-
-	err = netlink.LinkAdd(wglink)
-	if err != nil {
-		if os.IsExist(err) {
-			log.Println("WireGuard interface " + ifaceSettings.Name + " already exists. Skipping...")
-		} else {
-			return err
-		}
-	}
-	address, err := netlink.ParseAddr(wgconfig.GRPCWGAddress + "/24")
-	if err != nil {
-		return err
-	}
-
-	err = netlink.AddrAdd(wglink, address)
-	if err != nil && !os.IsExist(err) {
-		return err
-	}
-	err = netlink.LinkSetUp(wglink)
-	if err != nil {
-		log.Println("could not bring up wireguard interface")
-		return err
-	}
-	var client models.IntClient
-	client.PrivateKey = wgconfig.GRPCWGPrivKey
-	client.PublicKey = wgconfig.GRPCWGPubKey
-	client.ServerPublicEndpoint = servercfg.GetAPIHost()
-	client.ServerAPIPort = servercfg.GetAPIPort()
-	client.ServerPrivateAddress = servercfg.GetGRPCWGAddress()
-	client.ServerWGPort = servercfg.GetGRPCWGPort()
-	client.ServerGRPCPort = servercfg.GetGRPCPort()
-	client.Address = servercfg.GetGRPCWGAddress()
-	client.IsServer = "yes"
-	client.Network = "comms"
-	exists, _ := functions.GetServerIntClient()
-	if exists != nil {
-		err = RegisterServer(client)
-	}
-	return err
-}
-
-func DeleteServerClient() error {
-	return nil
-}
-
-func RegisterServer(client models.IntClient) error {
-	if client.PrivateKey == "" {
-		privateKey, err := wgtypes.GeneratePrivateKey()
-		if err != nil {
-			return err
-		}
-
-		client.PrivateKey = privateKey.String()
-		client.PublicKey = privateKey.PublicKey().String()
-	}
-
-	if client.Address == "" {
-		newAddress, err := functions.UniqueAddress(client.Network)
-		if err != nil {
-			return err
-		}
-		if newAddress == "" {
-			return errors.New("Could not retrieve address")
-		}
-		client.Address = newAddress
-	}
-	if client.Network == "" {
-		client.Network = "comms"
-	}
-	client.ServerKey = client.PublicKey
-	value, err := json.Marshal(client)
-	if err != nil {
-		return err
-	}
-	database.Insert(client.PublicKey, string(value), database.INT_CLIENTS_TABLE_NAME)
-
-	ReconfigureServerWireGuard()
-
-	return err
-}
-
-func ReconfigureServerWireGuard() error {
-	server, err := functions.GetServerIntClient()
-	if err != nil {
-		return err
-	}
-	serverkey, err := wgtypes.ParseKey(server.PrivateKey)
-	if err != nil {
-		return err
-	}
-	serverport, err := strconv.Atoi(servercfg.GetGRPCWGPort())
-	if err != nil {
-		return err
-	}
-
-	peers, err := functions.GetIntPeersList()
-	if err != nil {
-		return err
-	}
-	wgserver, err := wgctrl.New()
-	if err != nil {
-		return err
-	}
-	var serverpeers []wgtypes.PeerConfig
-	for _, peer := range peers {
-
-		pubkey, err := wgtypes.ParseKey(peer.PublicKey)
-		if err != nil {
-			return err
-		}
-		var peercfg wgtypes.PeerConfig
-		var allowedips []net.IPNet
-		if peer.Address != "" {
-			var peeraddr = net.IPNet{
-				IP:   net.ParseIP(peer.Address),
-				Mask: net.CIDRMask(32, 32),
-			}
-			allowedips = append(allowedips, peeraddr)
-		}
-		if peer.Address6 != "" {
-			var addr6 = net.IPNet{
-				IP:   net.ParseIP(peer.Address6),
-				Mask: net.CIDRMask(128, 128),
-			}
-			allowedips = append(allowedips, addr6)
-		}
-		peercfg = wgtypes.PeerConfig{
-			PublicKey:         pubkey,
-			ReplaceAllowedIPs: true,
-			AllowedIPs:        allowedips,
-		}
-		serverpeers = append(serverpeers, peercfg)
-	}
-
-	wgconf := wgtypes.Config{
-		PrivateKey:   &serverkey,
-		ListenPort:   &serverport,
-		ReplacePeers: true,
-		Peers:        serverpeers,
-	}
-	wgiface := servercfg.GetGRPCWGInterface()
-	err = wgserver.ConfigureDevice(wgiface, wgconf)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
 func GetPeers(networkName string) (map[string]string, error) {
 	peers := make(map[string]string)
 	network, err := functions.GetParentNetwork(networkName)