diff --git a/config/config.go b/config/config.go index a827e627..9623aca4 100644 --- a/config/config.go +++ b/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 { diff --git a/config/environments/dev.yaml b/config/environments/dev.yaml index fab0035a..a2cfcb5a 100644 --- a/config/environments/dev.yaml +++ b/config/environments/dev.yaml @@ -1,17 +1,18 @@ server: - host: "localhost" - apiport: "8081" - grpcport: "50051" - masterkey: "secretkey" - allowedorigin: "*" - restbackend: true - agentbackend: true - defaultnetname: "default" - defaultnetrange: "10.10.10.0/24" - createdefault: true + 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) + 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) mongoconn: - user: "mongoadmin" - pass: "mongopass" - host: "127.0.0.1" - port: "27017" - opts: '/?authSource=admin' + user: "" # defaults to "mongoadmin" or MONGO_ADMIN (if set) + pass: "" # defaults to "mongopass" or MONGO_PASS (if set) + host: "" # defaults to 127.0.0.1 or MONGO_HOST (if set) + port: "" # defaults to 27017 or MONGO_PORT (if set) + opts: '' # defaults to '/?authSource=admin' or MONGO_OPTS (if set) diff --git a/controllers/userHttpController.go b/controllers/userHttpController.go index cc180220..8bb8da6e 100644 --- a/controllers/userHttpController.go +++ b/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{ - Code: http.StatusUnauthorized, Message: "W1R3: Error Verifying Auth Token.", - } - returnErrorResponse(w, r, errorResponse) + returnErrorResponse(w, r, formatError(err, "internal")) 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) - return + returnErrorResponse(w, r, formatError(err, "internal")) + 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) - return + returnErrorResponse(w, r, formatError(err, "internal")) + return } admin, err = CreateUser(admin) if err != nil { - json.NewEncoder(w).Encode(err) - return + returnErrorResponse(w, r, formatError(err, "internal")) + 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) - return + returnErrorResponse(w, r, formatError(err, "internal")) + 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) - return + returnErrorResponse(w, r, formatError(err, "internal")) + 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) - return + returnErrorResponse(w, r, formatError(err, "internal")) + return } user, err = UpdateUser(userchange, user) if err != nil { - json.NewEncoder(w).Encode(err) - return + returnErrorResponse(w, r, formatError(err, "internal")) + return } json.NewEncoder(w).Encode(user) diff --git a/docker-compose.yml b/docker-compose.yml index ea79912e..bbe39e3b 100644 --- a/docker-compose.yml +++ b/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 diff --git a/main.go b/main.go index 38ecce02..dcb0ac77 100644 --- a/main.go +++ b/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 - var clientmode string - var defaultnet string - flag.StringVar(&clientmode, "clientmode", "on", "Have a client on the server") - flag.StringVar(&defaultnet, "defaultnet", "on", "Create a default network") - flag.StringVar(&dnsmode, "dnsmode", "on", "Add DNS settings") - flag.Parse() - if clientmode == "on" { - - cmd := exec.Command("id", "-u") - output, err := cmd.Output() - - 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.") - } + if err != nil { + fmt.Println("Error running 'id -u' for prereq check. Please investigate or disable client mode.") + log.Fatal(err) + } + i, err := strconv.Atoi(string(output[:len(output)-1])) + if err != nil { + fmt.Println("Error retrieving uid from 'id -u' for prereq check. Please investigate or disable client mode.") + log.Fatal(err) + } + if i != 0 { + log.Fatal("To run in client mode requires root privileges. Either disable client mode or run with sudo.") + } } - log.Println("Server starting...") + //Start Mongodb mongoconn.ConnectDatabase() installserver := false - if !(defaultnet == "off") { - if config.Config.Server.CreateDefault { - created, err := createDefaultNetwork() - if err != nil { - fmt.Printf("Error creating default network: %v", err) - } - if created && clientmode != "off" { - installserver = true - } + + //Create the default network (default: 10.10.10.0/24) + created, err := serverctl.CreateDefaultNetwork() + if err != nil { + fmt.Printf("Error creating default network: %v", err) } + + if created && serverctl.IsClientMode() { + installserver = true } - if dnsmode == "on" { - err := controller.SetDNS() - if err != nil { - fmt.Printf("Error setting DNS: %v", err) - } - } + + //NOTE: Removed Check and Logic for DNS Mode + //Reasoning. DNS Logic is very small on server. Can run with little/no impact. Just sets a tiny config file. + //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 { - fmt.Println("Oops! No Server Mode selected. Nothing being served.") + if !serverctl.IsAgentBackend() && !serverctl.IsRestBackend { + 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 := ":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) - } - + grpcport := serverctl.GetGRPCPort() 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) - success, err := serverctl.AddNetwork(config.Config.Server.DefaultNetName) + fmt.Println("Adding server to default network") + 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) } - diff --git a/mongoconn/mongoconn.go b/mongoconn/mongoconn.go index 649c5df5..f4108828 100644 --- a/mongoconn/mongoconn.go +++ b/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.") -} - -//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 + log.Println("MongoDB Connected.") } // 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) -} diff --git a/netclient/config/config.go b/netclient/config/config.go index a0da4b02..48b60170 100644 --- a/netclient/config/config.go +++ b/netclient/config/config.go @@ -234,9 +234,3 @@ func ReadConfig(network string) (*ClientConfig, error) { } return &cfg, err } -/* -func init() { - Config = readConfig() -} -*/ - diff --git a/netclient/functions/common.go b/netclient/functions/common.go index 38c1ac4b..7861583c 100644 --- a/netclient/functions/common.go +++ b/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 { diff --git a/serverctl/getconf.go b/serverctl/getconf.go new file mode 100644 index 00000000..5c6fc184 --- /dev/null +++ b/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 +} diff --git a/serverctl/serverctl.go b/serverctl/serverctl.go index 61d8a6a1..df4bd1be 100644 --- a/serverctl/serverctl.go +++ b/serverctl/serverctl.go @@ -11,37 +11,159 @@ import ( "os/exec" ) -func GetPublicIP() (string, error) { +func CreateDefaultNetwork() (bool, error) { - endpoint := "" - var err error + fmt.Println("Creating default network...") - if os.Getenv("SERVER_DOMAIN") != "" { - endpoint = os.Getenv("SERVER_DOMAIN") + iscreated := false + 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"} - 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 - } + var network models.Network + + network.NetID = "default" + network.AddressRange = "10.10.10.0/24" + network.DisplayName = "default" + 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 && endpoint == "" { - err = errors.New("Public Address Not Found.") + if err == nil { + 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 {