refactoring logic in main

config/config.go

@@ -44,7 +44,6 @@ type ServerConfig struct {
   AgentBackend bool `yaml:"agentbackend"`
   DefaultNetName string `yaml:"defaultnetname"`
   DefaultNetRange string `yaml:"defaultnetrange"`
-  CreateDefault bool `yaml:"createdefault"`
 }
 
 type MongoConnConfig struct {

config/environments/dev.yaml

@@ -1,17 +1,18 @@
 server:
-  host: "localhost"
+  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: "8081"
+  apiport: "" # defaults to 8081 or HTTP_PORT (if set)
-  grpcport: "50051"
+  grpchost: "" # defaults to 127.0.0.1 or remote ip (SERVER_HOST) if DisableRemoteIPCheck is not set to true. SERVER_GRPC_HOST if set.
-  masterkey: "secretkey"
+  grpcport: "" # defaults to 50051 or GRPC_PORT (if set)
-  allowedorigin: "*"
+  masterkey: "" # defaults to 'secretkey' or MASTER_KEY (if set)
-  restbackend: true            
+  allowedorigin: "" # defaults to '*' or CORS_ALLOWED_ORIGIN (if set)
-  agentbackend: true
+  restbackend: "" # defaults to "on" or REST_BACKEND (if set)
-  defaultnetname: "default"
+  agentbackend: "" # defaults to "on" or AGENT_BACKEND (if set)
-  defaultnetrange: "10.10.10.0/24"
+  clientmode: "" # defaults to "on" or CLIENT_MODE (if set)
-  createdefault: true
+  dnsmode: "" # defaults to "on" or DNS_MODE (if set)
+  disableremoteipcheck: "" # defaults to "false" or DISABLE_REMOTE_IP_CHECK (if set)
 mongoconn:
-  user: "mongoadmin"
+  user: "" # defaults to "mongoadmin" or MONGO_ADMIN (if set)
-  pass: "mongopass"
+  pass: "" # defaults to "mongopass" or MONGO_PASS (if set)
-  host: "127.0.0.1"
+  host: "" # defaults to 127.0.0.1 or MONGO_HOST (if set)
-  port: "27017"
+  port: "" # defaults to 27017 or MONGO_PORT (if set)
-  opts: '/?authSource=admin'
+  opts: '' # defaults to '/?authSource=admin' or MONGO_OPTS (if set)

controllers/userHttpController.go

@@ -156,10 +156,7 @@ func authorizeUser(next http.Handler) http.HandlerFunc {
 		username, _, err := functions.VerifyUserToken(authToken)
 
 		if err != nil {
-			errorResponse = models.ErrorResponse{
+			returnErrorResponse(w, r, formatError(err, "internal"))
-				Code: http.StatusUnauthorized, Message: "W1R3: Error Verifying Auth Token.",
-			}
-			returnErrorResponse(w, r, errorResponse)
 			return
 		}
 
@@ -240,8 +237,8 @@ func getUser(w http.ResponseWriter, r *http.Request) {
 	user, err := GetUser(params["username"])
 
 	if err != nil {
-		mongoconn.GetError(err, w)
+                returnErrorResponse(w, r, formatError(err, "internal"))
-		return
+                return
 	}
 
 	json.NewEncoder(w).Encode(user)
@@ -304,14 +301,14 @@ func createAdmin(w http.ResponseWriter, r *http.Request) {
 
 	err = ValidateUser("create", admin)
 	if err != nil {
-		json.NewEncoder(w).Encode(err)
+                returnErrorResponse(w, r, formatError(err, "internal"))
-		return
+                return
 	}
 
 	admin, err = CreateUser(admin)
 	if err != nil {
-		json.NewEncoder(w).Encode(err)
+                returnErrorResponse(w, r, formatError(err, "internal"))
-		return
+                return
 	}
 
 	json.NewEncoder(w).Encode(admin)
@@ -379,8 +376,8 @@ func updateUser(w http.ResponseWriter, r *http.Request) {
 	//start here
 	user, err := GetUser(params["username"])
 	if err != nil {
-		json.NewEncoder(w).Encode(err)
+                returnErrorResponse(w, r, formatError(err, "internal"))
-		return
+                return
 	}
 
 	var userchange models.User
@@ -388,8 +385,8 @@ func updateUser(w http.ResponseWriter, r *http.Request) {
 	// we decode our body request params
 	err = json.NewDecoder(r.Body).Decode(&userchange)
 	if err != nil {
-		json.NewEncoder(w).Encode(err)
+                returnErrorResponse(w, r, formatError(err, "internal"))
-		return
+                return
 	}
 
 	userchange.IsAdmin = true
@@ -397,15 +394,15 @@ func updateUser(w http.ResponseWriter, r *http.Request) {
 	err = ValidateUser("update", userchange)
 
 	if err != nil {
-		json.NewEncoder(w).Encode(err)
+                returnErrorResponse(w, r, formatError(err, "internal"))
-		return
+                return
 	}
 
 	user, err = UpdateUser(userchange, user)
 
 	if err != nil {
-		json.NewEncoder(w).Encode(err)
+                returnErrorResponse(w, r, formatError(err, "internal"))
-		return
+                return
 	}
 
 	json.NewEncoder(w).Encode(user)

docker-compose.yml

@@ -36,7 +36,6 @@ services:
       - /sys/fs/cgroup:/sys/fs/cgroup
     environment:
       MONGO_HOST: "127.0.0.1"
-      SERVER_DOMAIN: "3.236.149.180"
     cap_add:
       - NET_ADMIN
       - SYS_MODULE

main.go

@@ -29,72 +29,63 @@ import (
     "google.golang.org/grpc"
 )
 
-var ServerGRPC string
-var PortGRPC string
-
 //Start MongoDB Connection and start API Request Handler
 func main() {
 
+	//Client Mode Prereq Check
+	if serverctl.IsClientMode() {
+		cmd := exec.Command("id", "-u")
+		output, err := cmd.Output()
 
-	var dnsmode string
+		if err != nil {
-	var clientmode string
+			fmt.Println("Error running 'id -u' for prereq check. Please investigate or disable client mode.")
-	var defaultnet string
+			log.Fatal(err)
-	flag.StringVar(&clientmode, "clientmode", "on", "Have a client on the server")
+		}
-	flag.StringVar(&defaultnet, "defaultnet", "on", "Create a default network")
+		i, err := strconv.Atoi(string(output[:len(output)-1]))
-	flag.StringVar(&dnsmode, "dnsmode", "on", "Add DNS settings")
+		if err != nil {
-	flag.Parse()
+                        fmt.Println("Error retrieving uid from 'id -u' for prereq check. Please investigate or disable client mode.")
-	if clientmode == "on" {
+			log.Fatal(err)
-
+		}
-         cmd := exec.Command("id", "-u")
+		if i != 0 {
-         output, err := cmd.Output()
+			log.Fatal("To run in client mode requires root privileges. Either disable client mode or run with sudo.")
-
+		}
-         if err != nil {
-                 log.Fatal(err)
-         }
-         i, err := strconv.Atoi(string(output[:len(output)-1]))
-         if err != nil {
-                 log.Fatal(err)
-         }
-
-         if i != 0 {
-                 log.Fatal("To run in client mode requires root privileges. Either turn off client mode with the --clientmode=off flag, or run with sudo.")
-         }
 	}
 
-	log.Println("Server starting...")
+	//Start Mongodb
 	mongoconn.ConnectDatabase()
 
 	installserver := false
-	if !(defaultnet == "off") {
+
-	if config.Config.Server.CreateDefault {
+	//Create the default network (default: 10.10.10.0/24)
-		created, err := createDefaultNetwork()
+	created, err := serverctl.CreateDefaultNetwork()
-		if err != nil {
+	if err != nil {
-			fmt.Printf("Error creating default network: %v", err)
+		fmt.Printf("Error creating default network: %v", err)
-		}
-		if created && clientmode != "off" {
-			installserver = true
-		}
 	}
+
+	if created && serverctl.IsClientMode() {
+		installserver = true
 	}
-	if dnsmode == "on" {
+
-		err := controller.SetDNS()
+	//NOTE: Removed Check and Logic for DNS Mode
-                if err != nil {
+	//Reasoning. DNS Logic is very small on server. Can run with little/no impact. Just sets a tiny config file.
-                        fmt.Printf("Error setting DNS: %v", err)
+	//Real work is done by CoreDNS
-                }
+	//We can just not run CoreDNS. On Agent side is only necessary check for IsDNSMode, which we will pass.
-	}
+
 	var waitnetwork sync.WaitGroup
 
-	if config.Config.Server.AgentBackend {
+	//Run Agent Server
+	if serverctl.IsAgentBackend() {
 		waitnetwork.Add(1)
 		go runGRPC(&waitnetwork, installserver)
 	}
 
-	if config.Config.Server.RestBackend {
+	//Run Rest Server
+	if serverctl.IsRestBackend() {
 		waitnetwork.Add(1)
 		controller.HandleRESTRequests(&waitnetwork)
 	}
-	if !config.Config.Server.RestBackend && !config.Config.Server.AgentBackend {
+	if !serverctl.IsAgentBackend() && !serverctl.IsRestBackend {
-		fmt.Println("Oops! No Server Mode selected. Nothing being served.")
+		fmt.Println("Oops! No Server Mode selected. Nothing is being served! Set either Agent mode (AGENT_BACKEND) or Rest mode (REST_BACKEND) to 'true'.")
 	}
 	waitnetwork.Wait()
 	fmt.Println("Exiting now.")
@@ -110,36 +101,7 @@ func runGRPC(wg *sync.WaitGroup, installserver bool) {
         // Pipe flags to one another (log.LstdFLags = log.Ldate | log.Ltime)
         log.SetFlags(log.LstdFlags | log.Lshortfile)
 
-        // Start our listener, 50051 is the default gRPC port
+	grpcport := serverctl.GetGRPCPort()
-	grpcport := ":50051"
-	if config.Config.Server.GrpcPort != "" {
-		grpcport = ":" + config.Config.Server.GrpcPort
-	}
-        if os.Getenv("GRPC_PORT") != "" {
-		grpcport = ":" + os.Getenv("GRPC_PORT")
-        }
-	PortGRPC = grpcport
-	if os.Getenv("SERVER_DOMAIN") == ""  {
-		if config.Config.Server.Host == "" {
-			ServerGRPC, _ = serverctl.GetPublicIP()
-		} else {
-			ServerGRPC = config.Config.Server.Host
-		}
-	} else {
-		ServerGRPC = os.Getenv("SERVER_DOMAIN")
-	}
-	fmt.Println("GRPC Server set to: " + ServerGRPC)
-	fmt.Println("GRPC Port set to: " + PortGRPC)
-	var gconf models.GlobalConfig
-	gconf.ServerGRPC = ServerGRPC
-	gconf.PortGRPC = PortGRPC
-	gconf.Name = "netmaker"
-	err := setGlobalConfig(gconf)
-
-	if err != nil && err != mongo.ErrNoDocuments{
-	      log.Fatalf("Unable to set global config: %v", err)
-	}
-
 
 	listener, err := net.Listen("tcp", grpcport)
         // Handle errors if any
@@ -168,8 +130,8 @@ func runGRPC(wg *sync.WaitGroup, installserver bool) {
         fmt.Println("Agent Server succesfully started on port " + grpcport + " (gRPC)")
 
 	if installserver {
-			fmt.Println("Adding server to " + config.Config.Server.DefaultNetName)
+			fmt.Println("Adding server to default network")
-                        success, err := serverctl.AddNetwork(config.Config.Server.DefaultNetName)
+                        success, err := serverctl.AddNetwork("default")
                         if err != nil {
                                 fmt.Printf("Error adding to default network: %v", err)
 				fmt.Println("")
@@ -184,8 +146,6 @@ func runGRPC(wg *sync.WaitGroup, installserver bool) {
 	}
         fmt.Println("Setup complete. You are ready to begin using netmaker.")
 
-
-
         // Right way to stop the server using a SHUTDOWN HOOK
         // Create a channel to receive OS signals
         c := make(chan os.Signal)
@@ -207,84 +167,6 @@ func runGRPC(wg *sync.WaitGroup, installserver bool) {
         mongoconn.Client.Disconnect(context.TODO())
         fmt.Println("MongoDB connection closed.")
 }
-func setGlobalConfig(globalconf models.GlobalConfig) (error) {
-
-        collection := mongoconn.Client.Database("netmaker").Collection("config")
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-	create, _, err := functions.GetGlobalConfig()
-	if create {
-		_, err := collection.InsertOne(ctx, globalconf)
-		defer cancel()
-		if err != nil {
-			if err == mongo.ErrNoDocuments || strings.Contains(err.Error(), "no documents in result"){
-				return nil
-			} else {
-				return err
-			}
-		}
-	} else {
-		filter := bson.M{"name": "netmaker"}
-		update := bson.D{
-			{"$set", bson.D{
-				{"servergrpc", globalconf.ServerGRPC},
-				{"portgrpc", globalconf.PortGRPC},
-			}},
-		}
-		err := collection.FindOneAndUpdate(ctx, filter, update).Decode(&globalconf)
-                        if err == mongo.ErrNoDocuments {
-			//if err == mongo.ErrNoDocuments || strings.Contains(err.Error(), "no documents in result"){
-                                return nil
-                        }
-	}
-	return err
-}
-
-func createDefaultNetwork() (bool, error) {
-
-	iscreated := false
-	exists, err := functions.NetworkExists(config.Config.Server.DefaultNetName)
-
-	if exists || err != nil {
-		fmt.Println("Default network already exists")
-		fmt.Println("Skipping default network create")
-		return iscreated, err
-	} else {
-
-	var network models.Network
-
-	network.NetID = config.Config.Server.DefaultNetName
-	network.AddressRange = config.Config.Server.DefaultNetRange
-	network.DisplayName = config.Config.Server.DefaultNetName
-        network.SetDefaults()
-        network.SetNodesLastModified()
-        network.SetNetworkLastModified()
-        network.KeyUpdateTimeStamp = time.Now().Unix()
-	priv := false
-	network.IsLocal = &priv
-        network.KeyUpdateTimeStamp = time.Now().Unix()
-	allow := true
-	network.AllowManualSignUp = &allow
-
-	fmt.Println("Creating default network.")
-
-
-        collection := mongoconn.Client.Database("netmaker").Collection("networks")
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-
-        // insert our network into the network table
-        _, err = collection.InsertOne(ctx, network)
-        defer cancel()
-
-	}
-	if err == nil {
-		iscreated = true
-	}
-	return iscreated, err
-
-
-}
 
 func authServerUnaryInterceptor() grpc.ServerOption {
 	return grpc.UnaryInterceptor(controller.AuthServerUnaryInterceptor)
@@ -292,4 +174,3 @@ func authServerUnaryInterceptor() grpc.ServerOption {
 func authServerStreamInterceptor() grpc.ServerOption {
         return grpc.StreamInterceptor(controller.AuthServerStreamInterceptor)
 }
-

mongoconn/mongoconn.go

@@ -2,10 +2,8 @@ package mongoconn
 
 import (
 	"context"
-	"encoding/json"
 	"log"
 	"os"
-	"net/http"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
         "github.com/gravitl/netmaker/config"
@@ -67,7 +65,6 @@ func setVars() {
 //TODO: are we  even using  this besides at startup? Is it truely necessary?
 //TODO: Use config file instead of os.Getenv
 func ConnectDatabase() {
-    log.Println("Database connecting...")
     // Set client options
 
     setVars()
@@ -80,9 +77,11 @@ func ConnectDatabase() {
 						opts )
 
     // Connect to MongoDB
+    log.Println("Connecting to MongoDB at " + host + ":" + port + "...")
     client, err := mongo.Connect(context.TODO(), clientOptions)
     Client = client
     if err != nil {
+	log.Println("Error encountered connecting to MongoDB. Terminating.")
         log.Fatal(err)
     }
 
@@ -90,36 +89,14 @@ func ConnectDatabase() {
     err = Client.Ping(context.TODO(), nil)
 
     if err != nil {
+	log.Println("Error encountered pinging MongoDB. Terminating.")
         log.Fatal(err)
     }
 
     NodeDB = Client.Database("netmaker").Collection("nodes")
     NetworkDB = Client.Database("netmaker").Collection("networks")
 
-    log.Println("Database Connected.")
+    log.Println("MongoDB Connected.")
-}
-
-//TODO: IDK if we're using ConnectDB any more.... I think we're just using Client.Database
-//Review and see if this is necessary
-// ConnectDB : This is helper function to connect mongoDB
-func ConnectDB(db string, targetCollection string) *mongo.Collection {
-
-	// Set client options
-	//clientOptions := options.Client().ApplyURI("mongodb://mongoadmin:mongopassword@localhost:27017/?authSource=admin")
-	clientOptions := options.Client().ApplyURI("mongodb://" + os.Getenv("MONGO_USER") + ":" +
-	os.Getenv("MONGO_PASS") + "@" + os.Getenv("MONGO_HOST") + ":" + os.Getenv("MONGO_PORT") + os.Getenv("MONGO_OPTS") )
-
-	// Connect to MongoDB
-	client, err := mongo.Connect(context.TODO(), clientOptions)
-
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	//collection := client.Database("go_rest_api").Collection("wg")
-	collection := client.Database(db).Collection(targetCollection)
-
-	return collection
 }
 
 // ErrorResponse : This is error model.
@@ -127,17 +104,3 @@ type ErrorResponse struct {
 	StatusCode   int    `json:"status"`
 	ErrorMessage string `json:"message"`
 }
-
-// GetError : This is helper function to prepare error model.
-func GetError(err error, w http.ResponseWriter) {
-
-	var response = ErrorResponse{
-		ErrorMessage: err.Error(),
-		StatusCode:   http.StatusInternalServerError,
-	}
-
-	message, _ := json.Marshal(response)
-
-	w.WriteHeader(response.StatusCode)
-	w.Write(message)
-}

netclient/config/config.go

@@ -234,9 +234,3 @@ func ReadConfig(network string) (*ClientConfig, error) {
 	}
 	return &cfg, err
 }
-/*
-func init() {
-  Config = readConfig()
-}
-*/
-

netclient/functions/common.go

@@ -518,7 +518,7 @@ func getLocalIP(localrange string) (string, error) {
 
 func getPublicIP() (string, error) {
 
-	iplist := []string{"https://ifconfig.me", "http://api.ipify.org", "http://ipinfo.io/ip"}
+	iplist := []string{"http://ip.client.gravitl.com","https://ifconfig.me", "http://api.ipify.org", "http://ipinfo.io/ip"}
 	endpoint := ""
 	var err error
 	    for _, ipserver := range iplist {

serverctl/getconf.go

@@ -0,0 +1,159 @@
+package serverctl
+
+func SetHost() error {
+	remoteip, err := GetPublicIP()
+	if err != nil {
+		return err
+	}
+	os.Setenv("SERVER_HOST", remoteip)
+}
+func GetAPIHost() string {
+        serverhost := 127.0.0.1
+        if os.Getenv("SERVER_HTTP_HOST") != ""  {
+                serverhost = os.Getenv("SERVER_HTTP_HOST")
+        } else if config.Config.Server.APIHost != "" {
+		serverhost = config.Config.Server.APIHost
+        } else if os.Getenv("SERVER_HOST") != ""  {
+                serverhost = os.Getenv("SERVER_HOST")
+        }
+	return serverhost
+}
+func GetAPIPort() string {
+	apiport := "8081"
+	if os.Getenv("API_PORT") != "" {
+		apiport = os.Getenv("API_PORT")
+	} else if  config.Config.Server.APIPort != "" {
+		apiport = config.Config.Server.APIPort
+	}
+	return apiport
+}
+func GetGRPCHost() string {
+        serverhost := 127.0.0.1
+        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")
+        }
+        return serverhost
+}
+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
+}
+func GetMasterKey() string {
+        key := "secretkey"
+        if os.Getenv("MASTER_KEY") != "" {
+                key = os.Getenv("MASTER_KEY")
+        } else if  config.Config.Server.MasterKey != "" {
+                key = config.Config.Server.MasterKey
+        }
+        return key
+}
+func GetAllowedOrigin() string {
+        allowedorigin := "*"
+        if os.Getenv("CORS_ALLOWED_ORIGIN") != "" {
+                allowedorigin = os.Getenv("CORS_ALLOWED_ORIGIN")
+        } else if  config.Config.Server.AllowedOrigin != "" {
+                allowedorigin = config.Config.Server.AllowedOrigin
+        }
+        return allowedorigin
+}
+func IsRestBackend() bool {
+        isrest := true
+        if os.Getenv("REST_BACKEND") != "" {
+		if os.Getenv("REST_BACKEND") == "off"
+			isrest = false
+		}
+	} else if config.Config.Server.RestBackend != "" {
+		if config.Config.Server.RestBackend == "off" {
+			isrest = false
+		}
+       }
+       return isrest
+}
+func IsAgentBackend() bool {
+        isagent := true
+        if os.Getenv("AGENT_BACKEND") != "" {
+                if os.Getenv("AGENT_BACKEND") == "off"
+                        isagent = false
+                }
+        } else if config.Config.Server.AgentBackend != "" {
+                if config.Config.Server.AgentBackend == "off" {
+                        isagent = false
+                }
+       }
+       return isagent
+}
+func IsClientMode() bool {
+        isclient := true
+        if os.Getenv("CLIENT_MODE") != "" {
+                if os.Getenv("CLIENT_MODE") == "off"
+                        isclient = false
+                }
+        } else if config.Config.Server.ClientMode != "" {
+                if config.Config.Server.ClientMode == "off" {
+                        isclient = false
+                }
+       }
+       return isclient
+}
+func IsDNSMode() bool {
+        isdns := true
+        if os.Getenv("DNS_MODE") != "" {
+                if os.Getenv("DNS_MODE") == "off"
+                        isdns = false
+                }
+        } else if config.Config.Server.DNSMode != "" {
+                if config.Config.Server.DNSMode == "off" {
+                        isdns = false
+                }
+       }
+       return isdns
+}
+func DisableRemoteIPCheck() bool {
+        disabled := false
+        if os.Getenv("DISABLE_REMOTE_IP_CHECK") != "" {
+                if os.Getenv("DISABLE_REMOTE_IP_CHECK") == "on"
+                        disabled = true
+                }
+        } else if config.Config.Server.DisableRemoteIpCheck != "" {
+                if config.Config.Server.DisableRemoteIpCheck == "on" {
+                        disabled= true
+                }
+       }
+       return disabled
+}
+func GetPublicIP() (string, error) {
+
+        endpoint := ""
+        var err error
+
+        iplist := []string{"http://ip.server.gravitl.com", "https://ifconfig.me", "http://api.ipify.org", "http://ipinfo.io/ip"}
+        for _, ipserver := range iplist {
+                resp, err := http.Get(ipserver)
+                if err != nil {
+                        continue
+                }
+                defer resp.Body.Close()
+                if resp.StatusCode == http.StatusOK {
+                        bodyBytes, err := ioutil.ReadAll(resp.Body)
+                        if err != nil {
+                                continue
+                        }
+                        endpoint = string(bodyBytes)
+                        break
+                }
+
+        }
+        if err == nil && endpoint == "" {
+                err =  errors.New("Public Address Not Found.")
+        }
+        return endpoint, err
+}

serverctl/serverctl.go

@@ -11,37 +11,159 @@ import (
         "os/exec"
 )
 
-func GetPublicIP() (string, error) {
+func CreateDefaultNetwork() (bool, error) {
 
-        endpoint := ""
+        fmt.Println("Creating default network...")
-        var err error
 
-        if os.Getenv("SERVER_DOMAIN") != ""  {
+        iscreated := false
-                endpoint = os.Getenv("SERVER_DOMAIN")
+        exists, err := functions.NetworkExists(config.Config.Server.DefaultNetName)
+
+        if exists || err != nil {
+                fmt.Println("Default network already exists. Skipping...")
+                return iscreated, err
         } else {
 
-        iplist := []string{"https://ifconfig.me", "http://api.ipify.org", "http://ipinfo.io/ip"}
+        var network models.Network
-        for _, ipserver := range iplist {
+
-                resp, err := http.Get(ipserver)
+        network.NetID = "default"
-                if err != nil {
+        network.AddressRange = "10.10.10.0/24"
-                        continue
+        network.DisplayName = "default"
-                }
+        network.SetDefaults()
-                defer resp.Body.Close()
+        network.SetNodesLastModified()
-                if resp.StatusCode == http.StatusOK {
+        network.SetNetworkLastModified()
-                        bodyBytes, err := ioutil.ReadAll(resp.Body)
+        network.KeyUpdateTimeStamp = time.Now().Unix()
-                        if err != nil {
+        priv := false
-                                continue
+        network.IsLocal = &priv
-                        }
+        network.KeyUpdateTimeStamp = time.Now().Unix()
-                        endpoint = string(bodyBytes)
+        allow := true
-                        break
+        network.AllowManualSignUp = &allow
-                }
+
+        fmt.Println("Creating default network.")
+
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        // insert our network into the network table
+        _, err = collection.InsertOne(ctx, network)
+        defer cancel()
 
         }
-        if err == nil && endpoint == "" {
+        if err == nil {
-                err =  errors.New("Public Address Not Found.")
+                iscreated = true
         }
+        return iscreated, err
+
+
+}
+
+func GetHTTPPort() (string, error) {
+
+}
+
+func GetGRPCPort() (string, error) {
+
+}
+
+func GetServerDomain() (string, error) {
+
+}
+
+func modConfig(node *nodepb.Node) error{
+        network := node.Nodenetwork
+        if network == "" {
+                return errors.New("No Network Provided")
         }
-        return endpoint, err
+        modconfig, err := config.ReadConfig(network)
+        if err != nil {
+                return err
+        }
+        nodecfg := modconfig.Node
+        if node.Name != ""{
+                nodecfg.Name = node.Name
+        }
+        if node.Interface != ""{
+                nodecfg.Interface = node.Interface
+        }
+        if node.Nodenetwork != ""{
+                nodecfg.Network = node.Nodenetwork
+        }
+        if node.Macaddress != ""{
+                nodecfg.MacAddress = node.Macaddress
+        }
+        if node.Localaddress != ""{
+                nodecfg.LocalAddress = node.Localaddress
+        }
+        if node.Postup != ""{
+                nodecfg.PostUp = node.Postup
+        }
+        if node.Postdown != ""{
+                nodecfg.PostDown = node.Postdown
+        }
+        if node.Listenport != 0{
+                nodecfg.Port = node.Listenport
+        }
+        if node.Keepalive != 0{
+                nodecfg.KeepAlive = node.Keepalive
+        }
+        if node.Publickey != ""{
+                nodecfg.PublicKey = node.Publickey
+        }
+        if node.Endpoint != ""{
+                nodecfg.Endpoint = node.Endpoint
+        }
+        if node.Password != ""{
+                nodecfg.Password = node.Password
+        }
+        if node.Address != ""{
+                nodecfg.WGAddress = node.Address
+        }
+        if node.Postchanges != "" {
+                nodecfg.PostChanges = node.Postchanges
+        }
+        if node.Localrange != "" && node.Islocal {
+                nodecfg.IsLocal = true
+                nodecfg.LocalRange = node.Localrange
+        }
+        modconfig.Node = nodecfg
+        err = config.Write(modconfig, network)
+        return err
+}
+
+func SetGlobalConfig(globalconf models.GlobalConfig) (error) {
+
+        if err != nil && err != mongo.ErrNoDocuments{
+              log.Fatalf("Unable to set global config: %v", err)
+        }
+
+        collection := mongoconn.Client.Database("netmaker").Collection("config")
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        create, _, err := functions.GetGlobalConfig()
+        if create {
+                _, err := collection.InsertOne(ctx, globalconf)
+                defer cancel()
+                if err != nil {
+                        if err == mongo.ErrNoDocuments || strings.Contains(err.Error(), "no documents in result"){
+                                return nil
+                        } else {
+                                return err
+                        }
+                }
+        } else {
+                filter := bson.M{"name": "netmaker"}
+                update := bson.D{
+                        {"$set", bson.D{
+                                {"servergrpc", globalconf.ServerGRPC},
+                                {"portgrpc", globalconf.PortGRPC},
+                        }},
+                }
+                err := collection.FindOneAndUpdate(ctx, filter, update).Decode(&globalconf)
+                        if err == mongo.ErrNoDocuments {
+                        //if err == mongo.ErrNoDocuments || strings.Contains(err.Error(), "no documents in result"){
+                                return nil
+                        }
+        }
+        return err
 }
 
 func DownloadNetclient() error {