2021-05-06 06:03:37 +08:00
|
|
|
package servercfg
|
|
|
|
|
|
|
|
import (
|
2021-07-15 04:47:05 +08:00
|
|
|
"errors"
|
2022-01-07 04:05:38 +08:00
|
|
|
"io"
|
2021-10-14 03:15:20 +08:00
|
|
|
"net/http"
|
2021-05-06 06:03:37 +08:00
|
|
|
"os"
|
2021-07-03 11:25:36 +08:00
|
|
|
"strconv"
|
2021-10-21 02:17:31 +08:00
|
|
|
"strings"
|
2022-05-13 18:04:27 +08:00
|
|
|
"time"
|
2021-10-14 03:15:20 +08:00
|
|
|
|
2021-07-15 04:47:05 +08:00
|
|
|
"github.com/gravitl/netmaker/config"
|
2023-06-28 23:03:06 +08:00
|
|
|
|
2022-06-01 00:07:56 +08:00
|
|
|
"github.com/gravitl/netmaker/models"
|
2021-05-06 06:03:37 +08:00
|
|
|
)
|
2021-05-06 04:42:17 +08:00
|
|
|
|
2023-02-21 11:42:08 +08:00
|
|
|
// EmqxBrokerType denotes the broker type for EMQX MQTT
|
|
|
|
const EmqxBrokerType = "emqx"
|
|
|
|
|
2022-02-21 00:37:15 +08:00
|
|
|
var (
|
2023-08-03 14:46:58 +08:00
|
|
|
Version = "dev"
|
2023-09-01 10:12:05 +08:00
|
|
|
IsPro = false
|
2023-08-03 14:46:58 +08:00
|
|
|
ErrLicenseValidation error
|
2022-02-21 00:37:15 +08:00
|
|
|
)
|
2022-02-04 04:33:19 +08:00
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// SetHost - sets the host ip
|
2021-05-06 04:42:17 +08:00
|
|
|
func SetHost() error {
|
|
|
|
remoteip, err := GetPublicIP()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
os.Setenv("SERVER_HOST", remoteip)
|
2021-05-06 06:03:37 +08:00
|
|
|
return nil
|
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
|
|
|
// GetServerConfig - gets the server config into memory from file or env
|
2021-06-02 10:32:20 +08:00
|
|
|
func GetServerConfig() config.ServerConfig {
|
2021-05-06 06:03:37 +08:00
|
|
|
var cfg config.ServerConfig
|
2021-07-11 12:49:31 +08:00
|
|
|
cfg.APIConnString = GetAPIConnString()
|
2021-07-16 03:14:48 +08:00
|
|
|
cfg.CoreDNSAddr = GetCoreDNSAddr()
|
2021-05-06 06:03:37 +08:00
|
|
|
cfg.APIHost = GetAPIHost()
|
|
|
|
cfg.APIPort = GetAPIPort()
|
|
|
|
cfg.MasterKey = "(hidden)"
|
2021-11-16 00:42:52 +08:00
|
|
|
cfg.DNSKey = "(hidden)"
|
2021-05-06 06:03:37 +08:00
|
|
|
cfg.AllowedOrigin = GetAllowedOrigin()
|
|
|
|
cfg.RestBackend = "off"
|
2021-10-09 10:46:39 +08:00
|
|
|
cfg.NodeID = GetNodeID()
|
2022-12-12 13:03:35 +08:00
|
|
|
cfg.StunPort = GetStunPort()
|
2023-02-20 18:26:11 +08:00
|
|
|
cfg.BrokerType = GetBrokerType()
|
|
|
|
cfg.EmqxRestEndpoint = GetEmqxRestEndpoint()
|
2023-03-21 20:35:04 +08:00
|
|
|
if AutoUpdateEnabled() {
|
|
|
|
cfg.NetclientAutoUpdate = "enabled"
|
|
|
|
} else {
|
|
|
|
cfg.NetclientAutoUpdate = "disabled"
|
|
|
|
}
|
2021-05-06 06:03:37 +08:00
|
|
|
if IsRestBackend() {
|
|
|
|
cfg.RestBackend = "on"
|
|
|
|
}
|
|
|
|
cfg.DNSMode = "off"
|
|
|
|
if IsDNSMode() {
|
2021-07-15 04:47:05 +08:00
|
|
|
cfg.DNSMode = "on"
|
|
|
|
}
|
2021-11-15 05:50:20 +08:00
|
|
|
cfg.DisplayKeys = "off"
|
|
|
|
if IsDisplayKeys() {
|
|
|
|
cfg.DisplayKeys = "on"
|
|
|
|
}
|
2021-05-06 06:03:37 +08:00
|
|
|
cfg.DisableRemoteIPCheck = "off"
|
|
|
|
if DisableRemoteIPCheck() {
|
|
|
|
cfg.DisableRemoteIPCheck = "on"
|
|
|
|
}
|
2021-08-20 05:35:14 +08:00
|
|
|
cfg.Database = GetDB()
|
2021-08-20 01:41:04 +08:00
|
|
|
cfg.Platform = GetPlatform()
|
2021-08-17 04:30:55 +08:00
|
|
|
cfg.Version = GetVersion()
|
2021-10-21 02:17:31 +08:00
|
|
|
|
|
|
|
// == auth config ==
|
|
|
|
var authInfo = GetAuthProviderInfo()
|
|
|
|
cfg.AuthProvider = authInfo[0]
|
|
|
|
cfg.ClientID = authInfo[1]
|
|
|
|
cfg.ClientSecret = authInfo[2]
|
2021-10-22 03:28:58 +08:00
|
|
|
cfg.FrontendURL = GetFrontendURL()
|
2022-01-21 06:50:42 +08:00
|
|
|
cfg.Telemetry = Telemetry()
|
2022-04-12 22:43:02 +08:00
|
|
|
cfg.Server = GetServer()
|
2022-04-22 04:18:27 +08:00
|
|
|
cfg.Verbosity = GetVerbosity()
|
2023-09-01 10:12:05 +08:00
|
|
|
cfg.IsPro = "no"
|
|
|
|
if IsPro {
|
|
|
|
cfg.IsPro = "yes"
|
2022-09-23 03:01:59 +08:00
|
|
|
}
|
2023-10-02 12:57:58 +08:00
|
|
|
cfg.JwtValidityDuration = GetJwtValidityDuration()
|
|
|
|
cfg.RacAutoDisable = GetRacAutoDisable()
|
2021-10-22 03:28:58 +08:00
|
|
|
|
2021-05-06 06:03:37 +08:00
|
|
|
return cfg
|
2021-05-06 04:42:17 +08:00
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
2023-10-02 12:57:58 +08:00
|
|
|
// GetJwtValidityDuration - returns the JWT validity duration in seconds
|
|
|
|
func GetJwtValidityDuration() time.Duration {
|
|
|
|
var defaultDuration = time.Duration(24) * time.Hour
|
|
|
|
if os.Getenv("JWT_VALIDITY_DURATION") != "" {
|
|
|
|
t, err := strconv.Atoi(os.Getenv("JWT_VALIDITY_DURATION"))
|
|
|
|
if err != nil {
|
|
|
|
return defaultDuration
|
|
|
|
}
|
|
|
|
return time.Duration(t) * time.Second
|
|
|
|
}
|
|
|
|
return defaultDuration
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetRacAutoDisable - returns whether the feature to autodisable RAC is enabled
|
|
|
|
func GetRacAutoDisable() bool {
|
|
|
|
return os.Getenv("RAC_AUTO_DISABLE") == "true"
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetServerInfo - gets the server config into memory from file or env
|
2022-06-01 00:07:56 +08:00
|
|
|
func GetServerInfo() models.ServerConfig {
|
|
|
|
var cfg models.ServerConfig
|
2022-11-03 06:04:40 +08:00
|
|
|
cfg.Server = GetServer()
|
2023-01-20 12:19:43 +08:00
|
|
|
cfg.MQUserName = GetMqUserName()
|
|
|
|
cfg.MQPassword = GetMqPassword()
|
2022-06-01 00:07:56 +08:00
|
|
|
cfg.API = GetAPIConnString()
|
2022-05-31 20:42:12 +08:00
|
|
|
cfg.CoreDNSAddr = GetCoreDNSAddr()
|
|
|
|
cfg.APIPort = GetAPIPort()
|
|
|
|
cfg.DNSMode = "off"
|
2023-02-27 20:22:36 +08:00
|
|
|
cfg.Broker = GetPublicBrokerEndpoint()
|
2022-05-31 20:42:12 +08:00
|
|
|
if IsDNSMode() {
|
|
|
|
cfg.DNSMode = "on"
|
|
|
|
}
|
|
|
|
cfg.Version = GetVersion()
|
2023-09-01 10:12:05 +08:00
|
|
|
cfg.IsPro = IsPro
|
2022-10-26 13:23:57 +08:00
|
|
|
cfg.StunPort = GetStunPort()
|
2023-03-22 15:09:50 +08:00
|
|
|
cfg.TurnDomain = GetTurnHost()
|
2023-04-06 15:30:53 +08:00
|
|
|
cfg.TurnPort = GetTurnPort()
|
2023-04-28 16:36:28 +08:00
|
|
|
cfg.UseTurn = IsUsingTurn()
|
2022-05-31 20:42:12 +08:00
|
|
|
return cfg
|
|
|
|
}
|
|
|
|
|
2023-04-06 12:50:34 +08:00
|
|
|
// GetTurnHost - fetches the turn host domain
|
|
|
|
func GetTurnHost() string {
|
|
|
|
turnServer := ""
|
|
|
|
if os.Getenv("TURN_SERVER_HOST") != "" {
|
|
|
|
turnServer = os.Getenv("TURN_SERVER_HOST")
|
|
|
|
} else if config.Config.Server.TurnServer != "" {
|
|
|
|
turnServer = config.Config.Server.TurnServer
|
|
|
|
}
|
|
|
|
return turnServer
|
|
|
|
}
|
|
|
|
|
2023-04-28 16:36:28 +08:00
|
|
|
// IsUsingTurn - check if server has turn configured
|
|
|
|
func IsUsingTurn() (b bool) {
|
|
|
|
if os.Getenv("USE_TURN") != "" {
|
|
|
|
b = os.Getenv("USE_TURN") == "true"
|
|
|
|
} else {
|
|
|
|
b = config.Config.Server.UseTurn
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-04-06 12:50:34 +08:00
|
|
|
// GetTurnApiHost - fetches the turn api host domain
|
|
|
|
func GetTurnApiHost() string {
|
|
|
|
turnApiServer := ""
|
|
|
|
if os.Getenv("TURN_SERVER_API_HOST") != "" {
|
|
|
|
turnApiServer = os.Getenv("TURN_SERVER_API_HOST")
|
|
|
|
} else if config.Config.Server.TurnApiServer != "" {
|
|
|
|
turnApiServer = config.Config.Server.TurnApiServer
|
|
|
|
}
|
|
|
|
return turnApiServer
|
|
|
|
}
|
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// GetFrontendURL - gets the frontend url
|
2021-10-22 03:28:58 +08:00
|
|
|
func GetFrontendURL() string {
|
|
|
|
var frontend = ""
|
|
|
|
if os.Getenv("FRONTEND_URL") != "" {
|
|
|
|
frontend = os.Getenv("FRONTEND_URL")
|
|
|
|
} else if config.Config.Server.FrontendURL != "" {
|
|
|
|
frontend = config.Config.Server.FrontendURL
|
|
|
|
}
|
|
|
|
return frontend
|
|
|
|
}
|
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// GetAPIConnString - gets the api connections string
|
2021-07-11 12:49:31 +08:00
|
|
|
func GetAPIConnString() string {
|
2021-07-15 04:47:05 +08:00
|
|
|
conn := ""
|
|
|
|
if os.Getenv("SERVER_API_CONN_STRING") != "" {
|
|
|
|
conn = os.Getenv("SERVER_API_CONN_STRING")
|
|
|
|
} else if config.Config.Server.APIConnString != "" {
|
|
|
|
conn = config.Config.Server.APIConnString
|
|
|
|
}
|
|
|
|
return conn
|
2021-07-11 12:49:31 +08:00
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
2022-02-08 20:01:39 +08:00
|
|
|
// SetVersion - set version of netmaker
|
|
|
|
func SetVersion(v string) {
|
|
|
|
Version = v
|
|
|
|
}
|
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// GetVersion - version of netmaker
|
2021-08-17 04:30:55 +08:00
|
|
|
func GetVersion() string {
|
2022-02-04 04:33:19 +08:00
|
|
|
return Version
|
2021-08-17 04:30:55 +08:00
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
|
|
|
// GetDB - gets the database type
|
2021-08-19 06:12:08 +08:00
|
|
|
func GetDB() string {
|
2021-09-11 03:48:18 +08:00
|
|
|
database := "sqlite"
|
2021-10-09 01:11:31 +08:00
|
|
|
if os.Getenv("DATABASE") != "" {
|
2021-08-19 06:12:08 +08:00
|
|
|
database = os.Getenv("DATABASE")
|
2021-10-09 01:11:31 +08:00
|
|
|
} else if config.Config.Server.Database != "" {
|
2021-08-19 06:12:08 +08:00
|
|
|
database = config.Config.Server.Database
|
|
|
|
}
|
|
|
|
return database
|
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
|
|
|
// GetAPIHost - gets the api host
|
2021-05-06 04:42:17 +08:00
|
|
|
func GetAPIHost() string {
|
2021-07-15 04:47:05 +08:00
|
|
|
serverhost := "127.0.0.1"
|
2021-07-28 21:31:18 +08:00
|
|
|
remoteip, _ := GetPublicIP()
|
2021-07-15 04:47:05 +08:00
|
|
|
if os.Getenv("SERVER_HTTP_HOST") != "" {
|
|
|
|
serverhost = os.Getenv("SERVER_HTTP_HOST")
|
|
|
|
} else if config.Config.Server.APIHost != "" {
|
2021-05-06 04:42:17 +08:00
|
|
|
serverhost = config.Config.Server.APIHost
|
2021-07-15 04:47:05 +08:00
|
|
|
} else if os.Getenv("SERVER_HOST") != "" {
|
|
|
|
serverhost = os.Getenv("SERVER_HOST")
|
|
|
|
} else {
|
|
|
|
if remoteip != "" {
|
|
|
|
serverhost = remoteip
|
|
|
|
}
|
|
|
|
}
|
2021-05-06 04:42:17 +08:00
|
|
|
return serverhost
|
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
|
|
|
// GetAPIPort - gets the api port
|
2021-05-06 04:42:17 +08:00
|
|
|
func GetAPIPort() string {
|
|
|
|
apiport := "8081"
|
|
|
|
if os.Getenv("API_PORT") != "" {
|
|
|
|
apiport = os.Getenv("API_PORT")
|
2021-07-15 04:47:05 +08:00
|
|
|
} else if config.Config.Server.APIPort != "" {
|
2021-05-06 04:42:17 +08:00
|
|
|
apiport = config.Config.Server.APIPort
|
|
|
|
}
|
|
|
|
return apiport
|
|
|
|
}
|
2021-05-26 00:48:04 +08:00
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// GetCoreDNSAddr - gets the core dns address
|
2021-07-16 03:14:48 +08:00
|
|
|
func GetCoreDNSAddr() string {
|
2021-08-17 04:30:55 +08:00
|
|
|
addr, _ := GetPublicIP()
|
|
|
|
if os.Getenv("COREDNS_ADDR") != "" {
|
|
|
|
addr = os.Getenv("COREDNS_ADDR")
|
|
|
|
} else if config.Config.Server.CoreDNSAddr != "" {
|
2022-04-22 03:53:44 +08:00
|
|
|
addr = config.Config.Server.CoreDNSAddr
|
2021-08-17 04:30:55 +08:00
|
|
|
}
|
|
|
|
return addr
|
2021-07-16 03:14:48 +08:00
|
|
|
}
|
|
|
|
|
2023-02-27 20:22:36 +08:00
|
|
|
// GetPublicBrokerEndpoint - returns the public broker endpoint which shall be used by netclient
|
|
|
|
func GetPublicBrokerEndpoint() string {
|
|
|
|
if os.Getenv("BROKER_ENDPOINT") != "" {
|
|
|
|
return os.Getenv("BROKER_ENDPOINT")
|
|
|
|
} else {
|
2023-02-27 23:49:59 +08:00
|
|
|
return config.Config.Server.Broker
|
2022-02-19 04:18:50 +08:00
|
|
|
}
|
2022-05-25 22:31:44 +08:00
|
|
|
}
|
|
|
|
|
2022-01-13 05:23:34 +08:00
|
|
|
// GetMessageQueueEndpoint - gets the message queue endpoint
|
2022-07-08 03:38:13 +08:00
|
|
|
func GetMessageQueueEndpoint() (string, bool) {
|
2022-01-13 05:23:34 +08:00
|
|
|
host, _ := GetPublicIP()
|
2023-02-23 20:18:37 +08:00
|
|
|
if os.Getenv("SERVER_BROKER_ENDPOINT") != "" {
|
|
|
|
host = os.Getenv("SERVER_BROKER_ENDPOINT")
|
|
|
|
} else if config.Config.Server.ServerBrokerEndpoint != "" {
|
|
|
|
host = config.Config.Server.ServerBrokerEndpoint
|
|
|
|
} else if os.Getenv("BROKER_ENDPOINT") != "" {
|
2023-02-23 00:32:43 +08:00
|
|
|
host = os.Getenv("BROKER_ENDPOINT")
|
2023-02-27 23:49:59 +08:00
|
|
|
} else if config.Config.Server.Broker != "" {
|
|
|
|
host = config.Config.Server.Broker
|
2022-11-10 21:15:14 +08:00
|
|
|
} else {
|
2023-02-22 23:15:13 +08:00
|
|
|
host += ":1883" // default
|
2023-02-21 11:42:08 +08:00
|
|
|
}
|
2023-02-28 11:59:49 +08:00
|
|
|
return host, strings.Contains(host, "wss") || strings.Contains(host, "ssl") || strings.Contains(host, "mqtts")
|
2022-01-13 05:23:34 +08:00
|
|
|
}
|
|
|
|
|
2023-02-20 18:26:11 +08:00
|
|
|
// GetBrokerType - returns the type of MQ broker
|
|
|
|
func GetBrokerType() string {
|
|
|
|
if os.Getenv("BROKER_TYPE") != "" {
|
|
|
|
return os.Getenv("BROKER_TYPE")
|
|
|
|
} else {
|
|
|
|
return "mosquitto"
|
2022-11-10 21:15:14 +08:00
|
|
|
}
|
2022-01-13 05:23:34 +08:00
|
|
|
}
|
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// GetMasterKey - gets the configured master key of server
|
2021-05-06 04:42:17 +08:00
|
|
|
func GetMasterKey() string {
|
2022-02-14 22:58:50 +08:00
|
|
|
key := ""
|
2021-07-15 04:47:05 +08:00
|
|
|
if os.Getenv("MASTER_KEY") != "" {
|
|
|
|
key = os.Getenv("MASTER_KEY")
|
|
|
|
} else if config.Config.Server.MasterKey != "" {
|
|
|
|
key = config.Config.Server.MasterKey
|
|
|
|
}
|
|
|
|
return key
|
2021-05-06 04:42:17 +08:00
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
|
|
|
// GetAllowedOrigin - get the allowed origin
|
2021-05-06 04:42:17 +08:00
|
|
|
func GetAllowedOrigin() string {
|
2021-07-15 04:47:05 +08:00
|
|
|
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
|
2021-05-06 04:42:17 +08:00
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
|
|
|
// IsRestBackend - checks if rest is on or off
|
2021-05-06 04:42:17 +08:00
|
|
|
func IsRestBackend() bool {
|
2021-07-15 04:47:05 +08:00
|
|
|
isrest := true
|
|
|
|
if os.Getenv("REST_BACKEND") != "" {
|
2021-05-06 06:03:37 +08:00
|
|
|
if os.Getenv("REST_BACKEND") == "off" {
|
2021-05-06 04:42:17 +08:00
|
|
|
isrest = false
|
|
|
|
}
|
|
|
|
} else if config.Config.Server.RestBackend != "" {
|
|
|
|
if config.Config.Server.RestBackend == "off" {
|
|
|
|
isrest = false
|
|
|
|
}
|
2021-07-15 04:47:05 +08:00
|
|
|
}
|
|
|
|
return isrest
|
2021-05-06 04:42:17 +08:00
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
2022-09-14 03:25:56 +08:00
|
|
|
// IsMetricsExporter - checks if metrics exporter is on or off
|
|
|
|
func IsMetricsExporter() bool {
|
|
|
|
export := false
|
|
|
|
if os.Getenv("METRICS_EXPORTER") != "" {
|
|
|
|
if os.Getenv("METRICS_EXPORTER") == "on" {
|
|
|
|
export = true
|
|
|
|
}
|
|
|
|
} else if config.Config.Server.MetricsExporter != "" {
|
|
|
|
if config.Config.Server.MetricsExporter == "on" {
|
|
|
|
export = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return export
|
|
|
|
}
|
|
|
|
|
2022-01-13 05:23:34 +08:00
|
|
|
// IsMessageQueueBackend - checks if message queue is on or off
|
|
|
|
func IsMessageQueueBackend() bool {
|
|
|
|
ismessagequeue := true
|
|
|
|
if os.Getenv("MESSAGEQUEUE_BACKEND") != "" {
|
|
|
|
if os.Getenv("MESSAGEQUEUE_BACKEND") == "off" {
|
|
|
|
ismessagequeue = false
|
|
|
|
}
|
|
|
|
} else if config.Config.Server.MessageQueueBackend != "" {
|
|
|
|
if config.Config.Server.MessageQueueBackend == "off" {
|
|
|
|
ismessagequeue = false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ismessagequeue
|
|
|
|
}
|
|
|
|
|
2022-01-21 06:52:49 +08:00
|
|
|
// Telemetry - checks if telemetry data should be sent
|
2022-01-21 06:50:42 +08:00
|
|
|
func Telemetry() string {
|
|
|
|
telemetry := "on"
|
|
|
|
if os.Getenv("TELEMETRY") == "off" {
|
|
|
|
telemetry = "off"
|
|
|
|
}
|
|
|
|
if config.Config.Server.Telemetry == "off" {
|
|
|
|
telemetry = "off"
|
|
|
|
}
|
|
|
|
return telemetry
|
|
|
|
}
|
|
|
|
|
2022-04-12 22:43:02 +08:00
|
|
|
// GetServer - gets the server name
|
|
|
|
func GetServer() string {
|
|
|
|
server := ""
|
|
|
|
if os.Getenv("SERVER_NAME") != "" {
|
|
|
|
server = os.Getenv("SERVER_NAME")
|
|
|
|
} else if config.Config.Server.Server != "" {
|
|
|
|
server = config.Config.Server.Server
|
|
|
|
}
|
|
|
|
return server
|
|
|
|
}
|
|
|
|
|
2022-04-22 05:48:36 +08:00
|
|
|
func GetVerbosity() int32 {
|
2022-04-22 04:18:27 +08:00
|
|
|
var verbosity = 0
|
|
|
|
var err error
|
|
|
|
if os.Getenv("VERBOSITY") != "" {
|
|
|
|
verbosity, err = strconv.Atoi(os.Getenv("VERBOSITY"))
|
|
|
|
if err != nil {
|
|
|
|
verbosity = 0
|
|
|
|
}
|
|
|
|
} else if config.Config.Server.Verbosity != 0 {
|
2022-04-22 05:48:36 +08:00
|
|
|
verbosity = int(config.Config.Server.Verbosity)
|
2022-04-22 04:18:27 +08:00
|
|
|
}
|
2022-07-14 05:22:17 +08:00
|
|
|
if verbosity < 0 || verbosity > 4 {
|
2022-04-22 04:25:51 +08:00
|
|
|
verbosity = 0
|
|
|
|
}
|
2022-04-22 05:48:36 +08:00
|
|
|
return int32(verbosity)
|
2022-04-22 04:18:27 +08:00
|
|
|
}
|
|
|
|
|
2023-03-20 20:40:52 +08:00
|
|
|
// AutoUpdateEnabled returns a boolean indicating whether netclient auto update is enabled or disabled
|
|
|
|
// default is enabled
|
|
|
|
func AutoUpdateEnabled() bool {
|
2023-03-21 20:35:04 +08:00
|
|
|
if os.Getenv("NETCLIENT_AUTO_UPDATE") == "disabled" {
|
|
|
|
return false
|
|
|
|
} else if config.Config.Server.NetclientAutoUpdate == "disabled" {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return true
|
2023-03-20 20:40:52 +08:00
|
|
|
}
|
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// IsDNSMode - should it run with DNS
|
2021-05-06 04:42:17 +08:00
|
|
|
func IsDNSMode() bool {
|
2021-07-15 04:47:05 +08:00
|
|
|
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
|
2021-05-06 04:42:17 +08:00
|
|
|
}
|
2021-07-11 12:49:31 +08:00
|
|
|
|
2021-11-15 05:50:20 +08:00
|
|
|
// IsDisplayKeys - should server be able to display keys?
|
|
|
|
func IsDisplayKeys() bool {
|
|
|
|
isdisplay := true
|
|
|
|
if os.Getenv("DISPLAY_KEYS") != "" {
|
|
|
|
if os.Getenv("DISPLAY_KEYS") == "off" {
|
|
|
|
isdisplay = false
|
|
|
|
}
|
|
|
|
} else if config.Config.Server.DisplayKeys != "" {
|
|
|
|
if config.Config.Server.DisplayKeys == "off" {
|
|
|
|
isdisplay = false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return isdisplay
|
|
|
|
}
|
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// DisableRemoteIPCheck - disable the remote ip check
|
2021-05-06 04:42:17 +08:00
|
|
|
func DisableRemoteIPCheck() bool {
|
2021-07-15 04:47:05 +08:00
|
|
|
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
|
2021-05-06 04:42:17 +08:00
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
|
|
|
// GetPublicIP - gets public ip
|
2021-05-06 04:42:17 +08:00
|
|
|
func GetPublicIP() (string, error) {
|
|
|
|
|
2021-07-15 04:47:05 +08:00
|
|
|
endpoint := ""
|
|
|
|
var err error
|
2021-05-06 04:42:17 +08:00
|
|
|
|
2021-11-17 22:04:55 +08:00
|
|
|
iplist := []string{"https://ip.server.gravitl.com", "https://ifconfig.me", "https://api.ipify.org", "https://ipinfo.io/ip"}
|
2022-07-27 05:03:51 +08:00
|
|
|
publicIpService := os.Getenv("PUBLIC_IP_SERVICE")
|
|
|
|
if publicIpService != "" {
|
2022-07-28 02:57:37 +08:00
|
|
|
// prepend the user-specified service so it's checked first
|
|
|
|
iplist = append([]string{publicIpService}, iplist...)
|
|
|
|
} else if config.Config.Server.PublicIPService != "" {
|
|
|
|
publicIpService = config.Config.Server.PublicIPService
|
2022-07-27 05:03:51 +08:00
|
|
|
|
|
|
|
// prepend the user-specified service so it's checked first
|
|
|
|
iplist = append([]string{publicIpService}, iplist...)
|
|
|
|
}
|
|
|
|
|
2021-07-15 04:47:05 +08:00
|
|
|
for _, ipserver := range iplist {
|
2022-05-13 18:04:27 +08:00
|
|
|
client := &http.Client{
|
|
|
|
Timeout: time.Second * 10,
|
|
|
|
}
|
|
|
|
resp, err := client.Get(ipserver)
|
2021-07-15 04:47:05 +08:00
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode == http.StatusOK {
|
2022-01-07 04:05:38 +08:00
|
|
|
bodyBytes, err := io.ReadAll(resp.Body)
|
2021-07-15 04:47:05 +08:00
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
endpoint = string(bodyBytes)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if err == nil && endpoint == "" {
|
2021-12-07 04:31:08 +08:00
|
|
|
err = errors.New("public address not found")
|
2021-07-15 04:47:05 +08:00
|
|
|
}
|
|
|
|
return endpoint, err
|
|
|
|
}
|
2021-10-27 04:12:13 +08:00
|
|
|
|
|
|
|
// GetPlatform - get the system type of server
|
2021-08-20 01:41:04 +08:00
|
|
|
func GetPlatform() string {
|
|
|
|
platform := "linux"
|
|
|
|
if os.Getenv("PLATFORM") != "" {
|
|
|
|
platform = os.Getenv("PLATFORM")
|
2021-08-26 01:09:23 +08:00
|
|
|
} else if config.Config.Server.Platform != "" {
|
2023-02-20 11:47:11 +08:00
|
|
|
platform = config.Config.Server.Platform
|
2021-08-20 01:41:04 +08:00
|
|
|
}
|
|
|
|
return platform
|
|
|
|
}
|
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// GetSQLConn - get the sql connection string
|
2021-08-19 02:55:41 +08:00
|
|
|
func GetSQLConn() string {
|
|
|
|
sqlconn := "http://"
|
|
|
|
if os.Getenv("SQL_CONN") != "" {
|
|
|
|
sqlconn = os.Getenv("SQL_CONN")
|
2021-08-19 06:12:08 +08:00
|
|
|
} else if config.Config.Server.SQLConn != "" {
|
2021-08-19 02:55:41 +08:00
|
|
|
sqlconn = config.Config.Server.SQLConn
|
|
|
|
}
|
|
|
|
return sqlconn
|
2021-08-19 06:12:08 +08:00
|
|
|
}
|
2021-09-29 01:16:41 +08:00
|
|
|
|
2021-10-27 04:12:13 +08:00
|
|
|
// GetNodeID - gets the node id
|
2021-10-09 10:46:39 +08:00
|
|
|
func GetNodeID() string {
|
|
|
|
var id string
|
2022-02-15 05:19:19 +08:00
|
|
|
var err error
|
2022-02-01 22:59:23 +08:00
|
|
|
// id = getMacAddr()
|
2021-10-09 10:46:39 +08:00
|
|
|
if os.Getenv("NODE_ID") != "" {
|
|
|
|
id = os.Getenv("NODE_ID")
|
|
|
|
} else if config.Config.Server.NodeID != "" {
|
2022-02-15 04:28:43 +08:00
|
|
|
id = config.Config.Server.NodeID
|
2022-02-15 05:19:19 +08:00
|
|
|
} else {
|
|
|
|
id, err = os.Hostname()
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
2021-10-09 10:46:39 +08:00
|
|
|
}
|
|
|
|
return id
|
|
|
|
}
|
|
|
|
|
2022-02-15 04:28:43 +08:00
|
|
|
func SetNodeID(id string) {
|
|
|
|
config.Config.Server.NodeID = id
|
|
|
|
}
|
|
|
|
|
2021-10-21 02:17:31 +08:00
|
|
|
// GetAuthProviderInfo = gets the oauth provider info
|
2022-06-25 23:47:00 +08:00
|
|
|
func GetAuthProviderInfo() (pi []string) {
|
2021-10-21 02:17:31 +08:00
|
|
|
var authProvider = ""
|
2022-06-25 23:47:00 +08:00
|
|
|
|
|
|
|
defer func() {
|
|
|
|
if authProvider == "oidc" {
|
|
|
|
if os.Getenv("OIDC_ISSUER") != "" {
|
|
|
|
pi = append(pi, os.Getenv("OIDC_ISSUER"))
|
|
|
|
} else if config.Config.Server.OIDCIssuer != "" {
|
|
|
|
pi = append(pi, config.Config.Server.OIDCIssuer)
|
|
|
|
} else {
|
|
|
|
pi = []string{"", "", ""}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2021-10-21 02:17:31 +08:00
|
|
|
if os.Getenv("AUTH_PROVIDER") != "" && os.Getenv("CLIENT_ID") != "" && os.Getenv("CLIENT_SECRET") != "" {
|
|
|
|
authProvider = strings.ToLower(os.Getenv("AUTH_PROVIDER"))
|
2022-06-25 23:47:00 +08:00
|
|
|
if authProvider == "google" || authProvider == "azure-ad" || authProvider == "github" || authProvider == "oidc" {
|
2021-10-21 02:17:31 +08:00
|
|
|
return []string{authProvider, os.Getenv("CLIENT_ID"), os.Getenv("CLIENT_SECRET")}
|
|
|
|
} else {
|
|
|
|
authProvider = ""
|
|
|
|
}
|
|
|
|
} else if config.Config.Server.AuthProvider != "" && config.Config.Server.ClientID != "" && config.Config.Server.ClientSecret != "" {
|
|
|
|
authProvider = strings.ToLower(config.Config.Server.AuthProvider)
|
2022-06-25 23:47:00 +08:00
|
|
|
if authProvider == "google" || authProvider == "azure-ad" || authProvider == "github" || authProvider == "oidc" {
|
2021-10-21 02:17:31 +08:00
|
|
|
return []string{authProvider, config.Config.Server.ClientID, config.Config.Server.ClientSecret}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return []string{"", "", ""}
|
|
|
|
}
|
|
|
|
|
2022-01-03 23:01:37 +08:00
|
|
|
// GetAzureTenant - retrieve the azure tenant ID from env variable or config file
|
|
|
|
func GetAzureTenant() string {
|
|
|
|
var azureTenant = ""
|
|
|
|
if os.Getenv("AZURE_TENANT") != "" {
|
|
|
|
azureTenant = os.Getenv("AZURE_TENANT")
|
|
|
|
} else if config.Config.Server.AzureTenant != "" {
|
|
|
|
azureTenant = config.Config.Server.AzureTenant
|
|
|
|
}
|
|
|
|
return azureTenant
|
|
|
|
}
|
|
|
|
|
2023-01-20 01:41:28 +08:00
|
|
|
// GetMqPassword - fetches the MQ password
|
|
|
|
func GetMqPassword() string {
|
2022-09-26 19:24:52 +08:00
|
|
|
password := ""
|
2023-01-20 01:41:28 +08:00
|
|
|
if os.Getenv("MQ_PASSWORD") != "" {
|
|
|
|
password = os.Getenv("MQ_PASSWORD")
|
|
|
|
} else if config.Config.Server.MQPassword != "" {
|
|
|
|
password = config.Config.Server.MQPassword
|
|
|
|
}
|
|
|
|
return password
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetMqUserName - fetches the MQ username
|
|
|
|
func GetMqUserName() string {
|
|
|
|
password := ""
|
|
|
|
if os.Getenv("MQ_USERNAME") != "" {
|
|
|
|
password = os.Getenv("MQ_USERNAME")
|
|
|
|
} else if config.Config.Server.MQUserName != "" {
|
|
|
|
password = config.Config.Server.MQUserName
|
2022-09-26 19:24:52 +08:00
|
|
|
}
|
|
|
|
return password
|
|
|
|
}
|
2022-09-26 20:17:20 +08:00
|
|
|
|
2023-02-20 18:26:11 +08:00
|
|
|
// GetEmqxRestEndpoint - returns the REST API Endpoint of EMQX
|
|
|
|
func GetEmqxRestEndpoint() string {
|
|
|
|
return os.Getenv("EMQX_REST_ENDPOINT")
|
|
|
|
}
|
|
|
|
|
2022-09-14 03:25:56 +08:00
|
|
|
// IsBasicAuthEnabled - checks if basic auth has been configured to be turned off
|
|
|
|
func IsBasicAuthEnabled() bool {
|
|
|
|
var enabled = true //default
|
|
|
|
if os.Getenv("BASIC_AUTH") != "" {
|
|
|
|
enabled = os.Getenv("BASIC_AUTH") == "yes"
|
|
|
|
} else if config.Config.Server.BasicAuth != "" {
|
|
|
|
enabled = config.Config.Server.BasicAuth == "yes"
|
|
|
|
}
|
|
|
|
return enabled
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetLicenseKey - retrieves pro license value from env or conf files
|
|
|
|
func GetLicenseKey() string {
|
|
|
|
licenseKeyValue := os.Getenv("LICENSE_KEY")
|
|
|
|
if licenseKeyValue == "" {
|
|
|
|
licenseKeyValue = config.Config.Server.LicenseValue
|
|
|
|
}
|
|
|
|
return licenseKeyValue
|
|
|
|
}
|
|
|
|
|
2023-07-13 10:53:34 +08:00
|
|
|
// GetNetmakerTenantID - get's the associated, Netmaker, tenant ID to verify ownership
|
|
|
|
func GetNetmakerTenantID() string {
|
|
|
|
netmakerTenantID := os.Getenv("NETMAKER_TENANT_ID")
|
|
|
|
if netmakerTenantID == "" {
|
|
|
|
netmakerTenantID = config.Config.Server.NetmakerTenantID
|
2022-09-14 03:25:56 +08:00
|
|
|
}
|
2023-07-13 10:53:34 +08:00
|
|
|
return netmakerTenantID
|
2022-09-14 03:25:56 +08:00
|
|
|
}
|
2022-10-26 13:23:57 +08:00
|
|
|
|
2023-03-03 23:52:05 +08:00
|
|
|
// GetStunPort - Get the port to run the stun server on
|
2022-12-09 00:15:32 +08:00
|
|
|
func GetStunPort() int {
|
|
|
|
port := 3478 //default
|
2022-10-26 13:23:57 +08:00
|
|
|
if os.Getenv("STUN_PORT") != "" {
|
2022-12-09 00:15:32 +08:00
|
|
|
portInt, err := strconv.Atoi(os.Getenv("STUN_PORT"))
|
|
|
|
if err == nil {
|
|
|
|
port = portInt
|
|
|
|
}
|
|
|
|
} else if config.Config.Server.StunPort != 0 {
|
2022-10-26 13:23:57 +08:00
|
|
|
port = config.Config.Server.StunPort
|
|
|
|
}
|
|
|
|
return port
|
|
|
|
}
|
2022-11-20 12:05:29 +08:00
|
|
|
|
2023-04-06 15:30:53 +08:00
|
|
|
// GetTurnPort - Get the port to run the turn server on
|
|
|
|
func GetTurnPort() int {
|
|
|
|
port := 3479 //default
|
|
|
|
if os.Getenv("TURN_PORT") != "" {
|
|
|
|
portInt, err := strconv.Atoi(os.Getenv("TURN_PORT"))
|
|
|
|
if err == nil {
|
|
|
|
port = portInt
|
|
|
|
}
|
|
|
|
} else if config.Config.Server.TurnPort != 0 {
|
|
|
|
port = config.Config.Server.TurnPort
|
|
|
|
}
|
|
|
|
return port
|
|
|
|
}
|
|
|
|
|
2023-04-17 19:33:05 +08:00
|
|
|
// GetTurnUserName - fetches the turn server username
|
|
|
|
func GetTurnUserName() string {
|
|
|
|
userName := ""
|
|
|
|
if os.Getenv("TURN_USERNAME") != "" {
|
|
|
|
userName = os.Getenv("TURN_USERNAME")
|
|
|
|
} else {
|
|
|
|
userName = config.Config.Server.TurnUserName
|
|
|
|
}
|
|
|
|
return userName
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetTurnPassword - fetches the turn server password
|
|
|
|
func GetTurnPassword() string {
|
|
|
|
pass := ""
|
|
|
|
if os.Getenv("TURN_PASSWORD") != "" {
|
|
|
|
pass = os.Getenv("TURN_PASSWORD")
|
|
|
|
} else {
|
|
|
|
pass = config.Config.Server.TurnPassword
|
|
|
|
}
|
|
|
|
return pass
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2023-06-28 23:03:06 +08:00
|
|
|
// GetNetworkLimit - fetches free tier limits on users
|
|
|
|
func GetUserLimit() int {
|
|
|
|
var userslimit int
|
|
|
|
if os.Getenv("USERS_LIMIT") != "" {
|
|
|
|
userslimit, _ = strconv.Atoi(os.Getenv("USERS_LIMIT"))
|
|
|
|
} else {
|
|
|
|
userslimit = config.Config.Server.UsersLimit
|
|
|
|
}
|
|
|
|
return userslimit
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetNetworkLimit - fetches free tier limits on networks
|
|
|
|
func GetNetworkLimit() int {
|
|
|
|
var networkslimit int
|
|
|
|
if os.Getenv("NETWORKS_LIMIT") != "" {
|
|
|
|
networkslimit, _ = strconv.Atoi(os.Getenv("NETWORKS_LIMIT"))
|
|
|
|
} else {
|
|
|
|
networkslimit = config.Config.Server.NetworksLimit
|
|
|
|
}
|
|
|
|
return networkslimit
|
|
|
|
}
|
|
|
|
|
2023-08-09 01:47:49 +08:00
|
|
|
// GetMachinesLimit - fetches free tier limits on machines (clients + hosts)
|
|
|
|
func GetMachinesLimit() int {
|
|
|
|
if l, err := strconv.Atoi(os.Getenv("MACHINES_LIMIT")); err == nil {
|
|
|
|
return l
|
2023-06-28 23:03:06 +08:00
|
|
|
}
|
2023-08-09 01:47:49 +08:00
|
|
|
return config.Config.Server.MachinesLimit
|
2023-06-28 23:03:06 +08:00
|
|
|
}
|
|
|
|
|
2023-08-09 01:47:49 +08:00
|
|
|
// GetIngressLimit - fetches free tier limits on ingresses
|
|
|
|
func GetIngressLimit() int {
|
|
|
|
if l, err := strconv.Atoi(os.Getenv("INGRESSES_LIMIT")); err == nil {
|
|
|
|
return l
|
|
|
|
}
|
|
|
|
return config.Config.Server.IngressesLimit
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetEgressLimit - fetches free tier limits on egresses
|
|
|
|
func GetEgressLimit() int {
|
|
|
|
if l, err := strconv.Atoi(os.Getenv("EGRESSES_LIMIT")); err == nil {
|
|
|
|
return l
|
2023-06-28 23:03:06 +08:00
|
|
|
}
|
2023-08-09 01:47:49 +08:00
|
|
|
return config.Config.Server.EgressesLimit
|
2023-06-28 23:03:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// DeployedByOperator - returns true if the instance is deployed by netmaker operator
|
|
|
|
func DeployedByOperator() bool {
|
|
|
|
if os.Getenv("DEPLOYED_BY_OPERATOR") != "" {
|
|
|
|
return os.Getenv("DEPLOYED_BY_OPERATOR") == "true"
|
|
|
|
}
|
|
|
|
return config.Config.Server.DeployedByOperator
|
|
|
|
}
|
|
|
|
|
2023-08-08 18:29:38 +08:00
|
|
|
// GetEnvironment returns the environment the server is running in (e.g. dev, staging, prod...)
|
|
|
|
func GetEnvironment() string {
|
|
|
|
if env := os.Getenv("ENVIRONMENT"); env != "" {
|
|
|
|
return env
|
|
|
|
}
|
|
|
|
if env := config.Config.Server.Environment; env != "" {
|
|
|
|
return env
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|