gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-02-24 08:03:55 +08:00
Code Issues Projects Releases Packages Wiki Activity

refactoring logic in main

Browse source
This commit is contained in:
afeiszli 2021-05-05 20:42:17 +00:00
parent 731f938efe
commit 46a81c9767
10 changed files with 380 additions and 265 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
config/config.go
View file

@ -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 {

31
config/environments/dev.yaml
View file

@ -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)

33
controllers/userHttpController.go
View file

@ -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)

1
docker-compose.yml
View file

@ -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

199
main.go
View file

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

45
mongoconn/mongoconn.go
View file

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

6
netclient/config/config.go
View file

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

2
netclient/functions/common.go
View file

@ -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 {

159
serverctl/getconf.go Normal file
View file

@ -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
}

168
serverctl/serverctl.go
View file

@ -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 {