Merge f0bfc92295 into 4e399f63ea

Bumps [actions/setup-go](https://github.com/actions/setup-go) from 3 to 4.
- [Release notes](https://github.com/actions/setup-go/releases)
- [Commits](https://github.com/actions/setup-go/compare/v3...v4)

---
updated-dependencies:
- dependency-name: actions/setup-go
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/go.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Set up Go
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v4
       with:
         go-version: ^1.15
     - name: Check out code
@@ -22,7 +22,7 @@ jobs:
       run: make build
     - name: Test
       run: make test-with-coverage
-    # - uses: codecov/codecov-action@v1
+    - uses: codecov/codecov-action@v1
-    #   with:
+      with:
-    #     token: ${{ secrets.CODECOV_TOKEN }}
+        token: ${{ secrets.CODECOV_TOKEN }}
-    #     files: coverage.out
+        files: coverage.out

Makefile

@@ -21,6 +21,10 @@ build-arm64:
 build-armhf:
 	GOOS=linux GOARCH=arm RELEASE=prod make build
 
+build-amd64:
+	GOOS=linux GOARCH=amd64 RELEASE=prod make build
+
+
 build:
 	@echo "Building ${GOOS}-${GOARCH}"
 	GOOS=${GOOS} GOARCH=${GOARCH} go build \
@@ -41,9 +45,10 @@ test-with-coverage:
 	go test -tags=unit -timeout=600s -v ./... -coverprofile=coverage.out
 
 install:
-	sudo systemctl stop edgeboxctl
+	sudo systemctl stop edgeboxctl || true
-	sudo rm -rf /usr/local/bin/edgeboxctl /lib/systemd/system/edgeboxctl.service
+	sudo rm -rf /usr/local/bin/edgeboxctl /usr/local/sbin/edgeboctl /lib/systemd/system/edgeboxctl.service
 	sudo cp ./bin/edgeboxctl /usr/local/bin/edgeboxctl
+	sudo cp ./bin/edgeboxctl /usr/local/sbin/edgeboxctl
 	sudo cp ./edgeboxctl.service /lib/systemd/system/edgeboxctl.service
 	sudo systemctl daemon-reload
 	@echo "Edgeboxctl installed successfully"
@@ -53,6 +58,7 @@ install-prod: build-prod install
 install-cloud: build-cloud install
 install-arm64: build-arm64 install
 install-armhf: build-armhf install
+install-amd64: build-amd64 install
 
 start:
 	systemctl start edgeboxctl

codecov.yml

@@ -1,4 +1,3 @@
-codecov:
-  require_ci_to_pass: no
-
 comment: false
+github_checks:
+  annotations: false

internal/edgeapps/edgeapps.go

@@ -6,7 +6,7 @@ import (
 	"os"
 	"strings"
 	"time"
-
+	
 	"github.com/joho/godotenv"
 
 	"github.com/edgebox-iot/edgeboxctl/internal/system"
@@ -23,6 +23,9 @@ type EdgeApp struct {
 	InternetAccessible bool             `json:"internet_accessible"`
 	NetworkURL         string           `json:"network_url"`
 	InternetURL        string           `json:"internet_url"`
+	Options			   []EdgeAppOption  `json:"options"`
+	NeedsConfig		   bool             `json:"needs_config"`
+	Login              EdgeAppLogin	 	`json:"login"`
 }
 
 // MaybeEdgeApp : Boolean flag for validation of edgeapp existance
@@ -43,9 +46,29 @@ type EdgeAppService struct {
 	IsRunning bool   `json:"is_running"`
 }
 
+type EdgeAppOption struct {
+	Key             string `json:"key"`
+	Value           string `json:"value"`
+	DefaultValue    string `json:"default_value"`
+	Format          string `json:"format"`
+	Description     string `json:"description"`
+	IsSecret        bool   `json:"is_secret"`
+	IsInstallLocked bool   `json:"is_install_locked"`
+}
+
+type EdgeAppLogin struct {
+	Enabled  bool   `json:"enabled"`
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
 const configFilename = "/edgebox-compose.yml"
 const envFilename = "/edgebox.env"
+const optionsTemplateFilename = "/edgeapp.template.env"
+const optionsEnvFilename = "/edgeapp.env"
+const authEnvFilename = "/auth.env"
 const runnableFilename = "/.run"
+const appdataFoldername = "/appdata"
 const myEdgeAppServiceEnvFilename = "/myedgeapp.env"
 const defaultContainerOperationSleepTime time.Duration = time.Second * 10
 
@@ -63,6 +86,7 @@ func GetEdgeApp(ID string) MaybeEdgeApp {
 
 		edgeAppName := ID
 		edgeAppDescription := ""
+		edgeAppOptions := []EdgeAppOption{}
 
 		edgeAppEnv, err := godotenv.Read(utils.GetPath(utils.EdgeAppsPath) + ID + envFilename)
 
@@ -77,6 +101,103 @@ func GetEdgeApp(ID string) MaybeEdgeApp {
 			}
 		}
 
+		needsConfig := false
+		hasFilledOptions := false
+		edgeAppOptionsTemplate, err := godotenv.Read(utils.GetPath(utils.EdgeAppsPath) + ID + optionsTemplateFilename)
+		if err != nil {
+			log.Println("Error loading options template file for edgeapp " + edgeAppName)
+		} else {
+			// Try to read the edgeAppOptionsEnv file
+			edgeAppOptionsEnv, err := godotenv.Read(utils.GetPath(utils.EdgeAppsPath) + ID + optionsEnvFilename)
+			if err != nil {
+				log.Println("Error loading options env file for edgeapp " + edgeAppName)
+			} else {
+				hasFilledOptions = true
+			}
+
+			for key, value := range edgeAppOptionsTemplate {
+				
+				optionFilledValue := ""
+				if hasFilledOptions {
+					// Check if key exists in edgeAppOptionsEnv
+					optionFilledValue = edgeAppOptionsEnv[key]
+				}
+
+				format := ""
+				defaultValue := ""
+				description := ""
+				installLocked := false
+
+				// Parse value to separate by | and get the format, installLocked, description and default value
+				// Format is the first element
+				// InstallLocked is the second element
+				// Description is the third element
+				// Default value is the fourth element
+
+				valueSlices := strings.Split(value, "|")
+				if len(valueSlices) > 0 {
+					format = valueSlices[0]
+				}
+				if len(valueSlices) > 1 {
+					installLocked = valueSlices[1] == "true"
+				}
+				if len(valueSlices) > 2 {
+					description = valueSlices[2]
+				}
+				if len(valueSlices) > 3 {
+					defaultValue = valueSlices[3]
+				}
+
+				// // If value contains ">|", then get everything that is to the right of it as the description
+				// // and get everything between "<>" as the format
+				// if strings.Contains(value, ">|") {
+				// 	description = strings.Split(value, ">|")[1]
+				// 	// Check if description has default value. That would be everything that is to the right of the last "|"
+				// 	if strings.Contains(description, "|") {
+				// 		defaultValue = strings.Split(description, "|")[1]
+				// 		description = strings.Split(description, "|")[0]
+				// 	}
+
+				// 	value = strings.Split(value, ">|")[0]
+				// 	// Remove the initial < from value
+				// 	value = strings.TrimPrefix(value, "<")
+				// } else {
+				// 	// Trim initial < and final > from value
+				// 	value = strings.TrimPrefix(value, "<")
+				// 	value = strings.TrimSuffix(value, ">")
+				// }
+
+				isSecret := false
+
+				// Check if the lowercased key string contains the letters "pass", "secret", "key"
+				lowercaseKey := strings.ToLower(key)
+				// check if lowercaseInput contains "pass", "key", or "secret", or "token"
+				if strings.Contains(lowercaseKey, "pass") ||
+					strings.Contains(lowercaseKey, "key") ||
+					strings.Contains(lowercaseKey, "secret") ||
+					strings.Contains(lowercaseKey, "token") {
+					isSecret = true
+				}
+
+				currentOption := EdgeAppOption{
+					Key:             key,
+					Value:           optionFilledValue,
+					DefaultValue:    defaultValue,
+					Description:     description,
+					Format:          format,
+					IsSecret:        isSecret,
+					IsInstallLocked: installLocked,
+				}
+				edgeAppOptions = append(edgeAppOptions, currentOption)
+
+				if optionFilledValue == "" {
+					needsConfig = true
+				}
+
+			}
+		}
+
+
 		edgeAppInternetAccessible := false
 		edgeAppInternetURL := ""
 
@@ -90,6 +211,21 @@ func GetEdgeApp(ID string) MaybeEdgeApp {
 			}
 		}
 
+		edgeAppBasicAuthEnabled := false
+		edgeAppBasicAuthUsername := ""
+		edgeAppBasicAuthPassword := ""
+
+		edgeAppAuthEnv, err := godotenv.Read(utils.GetPath(utils.EdgeAppsPath) + ID + authEnvFilename)
+		if err != nil {
+			log.Println("No auth.env file found. Login status is disabled.")
+		} else {
+			if edgeAppAuthEnv["USERNAME"] != "" && edgeAppAuthEnv["PASSWORD"] != "" {
+				edgeAppBasicAuthEnabled = true
+				edgeAppBasicAuthUsername = edgeAppAuthEnv["USERNAME"]
+				edgeAppBasicAuthPassword = edgeAppAuthEnv["PASSWORD"]
+			}
+		}
+
 		result = MaybeEdgeApp{
 			EdgeApp: EdgeApp{
 				ID:                 ID,
@@ -98,8 +234,12 @@ func GetEdgeApp(ID string) MaybeEdgeApp {
 				Status:             GetEdgeAppStatus(ID),
 				Services:           GetEdgeAppServices(ID),
 				InternetAccessible: edgeAppInternetAccessible,
-				NetworkURL:         ID + system.GetHostname() + ".local",
+				NetworkURL:         ID + "." + system.GetHostname() + ".local",
 				InternetURL:        edgeAppInternetURL,
+				Options: 		    edgeAppOptions,
+				NeedsConfig:        needsConfig,
+				Login:				EdgeAppLogin{edgeAppBasicAuthEnabled, edgeAppBasicAuthUsername, edgeAppBasicAuthPassword},
+				
 			},
 			Valid: true,
 		}
@@ -154,11 +294,40 @@ func SetEdgeAppInstalled(ID string) bool {
 
 func SetEdgeAppNotInstalled(ID string) bool {
 
+	// Stop the app first
+	StopEdgeApp(ID)
+
+	// Now remove any files
 	result := true
+	
 	err := os.Remove(utils.GetPath(utils.EdgeAppsPath) + ID + runnableFilename)
 	if err != nil {
 		result = false
-		log.Fatal(err)
+		log.Println(err)
+	}
+
+	err = os.Remove(utils.GetPath(utils.EdgeAppsPath) + ID + authEnvFilename)
+	if err != nil {
+		result = false
+		log.Println(err)
+	}
+
+	err = os.RemoveAll(utils.GetPath(utils.EdgeAppsPath) + ID + appdataFoldername)
+	if err != nil {
+		result = false
+		log.Println(err)
+	}
+
+	err = os.Remove(utils.GetPath(utils.EdgeAppsPath) + ID + myEdgeAppServiceEnvFilename)
+	if err != nil {
+		result = false
+		log.Println(err)
+	}
+
+	err = os.Remove(utils.GetPath(utils.EdgeAppsPath) + ID + optionsEnvFilename)
+	if err != nil {
+		result = false
+		log.Println(err)
 	}
 
 	buildFrameworkContainers()

internal/system/system.go

@@ -92,6 +92,22 @@ func SetupCloudOptions() {
 		utils.WriteOption("EMAIL", cloudEnv["EMAIL"])
 	}
 
+	if cloudEnv["USERNAME"] != "" {
+		utils.WriteOption("USERNAME", cloudEnv["USERNAME"])
+	}
+
+	if cloudEnv["CLUSTER"] != "" {
+		utils.WriteOption("CLUSTER", cloudEnv["CLUSTER"])
+	}
+
+	if cloudEnv["CLUSTER_IP"] != "" {
+		utils.WriteOption("CLUSTER_IP", cloudEnv["CLUSTER_IP"])
+	}
+
+	if cloudEnv["CLUSTER_SSH_PORT"] != "" {
+		utils.WriteOption("CLUSTER_SSH_PORT", cloudEnv["CLUSTER_SSH_PORT"])
+	}
+
 	if cloudEnv["EDGEBOXIO_API_TOKEN"] != "" {
 		utils.WriteOption("EDGEBOXIO_API_TOKEN", cloudEnv["EDGEBOXIO_API_TOKEN"])
 	}
@@ -100,6 +116,37 @@ func SetupCloudOptions() {
 	utils.Exec("/", "rm", []string{cloudEnvFileLocationPath})
 }
 
+func StartSystemLogger() {
+	fmt.Println("Starting system logger")
+	loggerPath := utils.GetPath(utils.LoggerPath)
+	utils.Exec(loggerPath, "make", []string{"start"})
+}
+
+// UpdateSystemLoggerServices: Updates the services.txt file with the services that are currently running
+func UpdateSystemLoggerServices(services []string) {
+	fmt.Println("Updating system logger services:")
+	fmt.Println(services)
+	loggerPath := utils.GetPath(utils.LoggerPath)
+
+	utils.Exec(loggerPath, "bash", []string{"-c", "rm services.txt && touch services.txt"})
+
+	for _, service := range services {
+		fmt.Println("Adding " + service + " to services.txt")
+		utils.Exec(loggerPath, "bash", []string{"-c", "echo " + service + " >> services.txt"})
+	}
+
+	// Add empty line at the end of file (best practice)
+	utils.Exec(loggerPath, "bash", []string{"-c", "echo '' >> services.txt"})
+}
+
+// StartWs: Starts the webserver service for Edgeapps
+func StartWs() {
+	wsPath := utils.GetPath(utils.WsPath)
+	fmt.Println("Starting WS")
+	cmdargs := []string{"-b"}
+	utils.Exec(wsPath, "./ws", cmdargs)
+}
+
 // StartService: Starts a service
 func StartService(serviceID string) {
 	wsPath := utils.GetPath(utils.WsPath)

internal/tasks/tasks.go

@@ -33,6 +33,17 @@ type Task struct {
 	Updated string         `json:"updated"`
 }
 
+// TaskOption: Struct for Task Options (kv pair)
+type TaskOption struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+type TaskBasicAuth struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
 type taskSetupTunnelArgs struct {
 	DomainName string `json:"domain_name"`
 }
@@ -53,6 +64,21 @@ type taskStopEdgeAppArgs struct {
 	ID string `json:"id"`
 }
 
+type taskSetEdgeAppOptionsArgs struct {
+	ID string `json:"id"`
+	// Options should be an array of "key":"value" pairs
+	Options []TaskOption `json:"options"`
+}
+
+type taskSetEdgeAppBasicAuthArgs struct {
+	ID string `json:"id"`
+	Login TaskBasicAuth `json:"login"`
+}
+
+type taskRemoveEdgeAppBasicAuthArgs struct {
+	ID string `json:"id"`
+}
+
 type taskEnableOnlineArgs struct {
 	ID          string `json:"id"`
 	InternetURL string `json:"internet_url"`
@@ -262,6 +288,43 @@ func ExecuteTask(task Task) Task {
 				task.Result = sql.NullString{String: taskResult, Valid: true}
 			}
 
+		case "set_edgeapp_options":
+
+			log.Println("Setting EdgeApp Options...")
+			var args taskSetEdgeAppOptionsArgs
+			// {"id":"podgrab","options":{"PODGRAB_PASSWORD":"fumarmata"}}
+			err := json.Unmarshal([]byte(task.Args.String), &args)
+			if err != nil {
+				log.Printf("Error reading arguments of set_edgeapp_options task: %s", err)
+			} else {
+				taskResult := taskSetEdgeAppOptions(args)
+				task.Result = sql.NullString{String: taskResult, Valid: true}
+			}
+
+		case "set_edgeapp_basic_auth":
+
+			log.Println("Settig EdgeApp Basic Authentication...")
+			var args taskSetEdgeAppBasicAuthArgs
+			err := json.Unmarshal([]byte(task.Args.String), &args)
+			if err != nil {
+				log.Printf("Error reading arguments of set_edgeapp_basic_auth task: %s", err)
+			} else {
+				taskResult := taskSetEdgeAppBasicAuth(args)
+				task.Result = sql.NullString{String: taskResult, Valid: true}
+			}
+
+		case "remove_edgeapp_basic_auth":
+
+			log.Println("Removing EdgeApp Basic Authentication...")
+			var args taskRemoveEdgeAppBasicAuthArgs
+			err := json.Unmarshal([]byte(task.Args.String), &args)
+			if err != nil {
+				log.Printf("Error reading arguments of remove_edgeapp_basic_auth task: %s", err)
+			} else {
+				taskResult := taskRemoveEdgeAppBasicAuth(args)
+				task.Result = sql.NullString{String: taskResult, Valid: true}
+			}
+
 		case "enable_online":
 
 			log.Println("Enabling online access to EdgeApp...")
@@ -374,8 +437,9 @@ func ExecuteSchedules(tick int) {
 		log.Println("Uptime is " + uptime + " seconds (" + system.GetUptimeFormatted() + ")")
 
 		log.Println(taskGetStorageDevices())
+		taskStartWs()
 		log.Println(taskGetEdgeApps())
-
+		taskUpdateSystemLoggerServices()
 	}
 
 	if tick%5 == 0 {
@@ -387,6 +451,7 @@ func ExecuteSchedules(tick int) {
 	if tick%30 == 0 {
 		// Executing every 30 ticks
 		log.Println(taskGetEdgeApps())
+		taskUpdateSystemLoggerServices()
 		// RESET SOME VARIABLES HERE IF NEEDED, SINCE SYSTEM IS UNBLOCKED
 		utils.WriteOption("BACKUP_IS_WORKING", "0")
 
@@ -423,6 +488,12 @@ func ExecuteSchedules(tick int) {
 		// Executing every 3600 ticks (1 hour)
 	}
 
+	if tick%86400 == 0 {
+		// Executing every 86400 ticks (+/1 day)
+		// Ensuring we run a normal build, setting up avahi domain names fresh in the network
+		taskStartWs()
+	}
+
 	// Just add a schedule here if you need a custom one (every "tick hour", every "tick day", etc...)
 
 }
@@ -902,6 +973,128 @@ func taskStopEdgeApp(args taskStopEdgeAppArgs) string {
 	return string(resultJSON)
 }
 
+func taskSetEdgeAppOptions(args taskSetEdgeAppOptionsArgs) string {
+	// Id is the edgeapp id
+	appID := args.ID
+
+
+	// Open the file to write the options,
+	// it is an env file in /home/system/components/apps/<app_id>/edgeapp.env
+
+	// Get the path to the edgeapp.env file
+	edgeappEnvPath := "/home/system/components/apps/" + appID + "/edgeapp.env"
+
+	// If the file does not exist, create it
+	if _, err := os.Stat(edgeappEnvPath); os.IsNotExist(err) {
+		// Create the file
+		_, err := os.Create(edgeappEnvPath)
+		if err != nil {
+			log.Printf("Error creating edgeapp.env file: %s", err)
+		}
+	}
+
+	// It is an env file, so we can use go-dotenv to write the options
+	// Open the file
+	edgeappEnvFile, err := os.OpenFile(edgeappEnvPath, os.O_WRONLY, 0600)
+	if err != nil {
+		log.Printf("Error opening edgeapp.env file: %s", err)
+	}
+
+	// Write the options to the file
+	for _, value := range args.Options {
+		// Write the option to the file
+		_, err := edgeappEnvFile.WriteString(value.Key + "=" + value.Value + "\n")
+		if err != nil {
+			log.Printf("Error writing option to edgeapp.env file: %s", err)
+		}
+	}
+	
+	// Close the file
+	err = edgeappEnvFile.Close()
+	if err != nil {
+		log.Printf("Error closing edgeapp.env file: %s", err)
+	}
+
+	result := edgeapps.GetEdgeAppStatus(appID)
+	resultJSON, _ := json.Marshal(result)
+
+	system.StartWs()
+	taskGetEdgeApps() // This task will imediatelly update the entry in the api database.
+
+	return string(resultJSON)
+}
+
+func taskSetEdgeAppBasicAuth(args taskSetEdgeAppBasicAuthArgs) string {
+	// Id is the edgeapp id
+	appID := args.ID
+
+
+	// Open the file to write the options,
+	// it is an env file in /home/system/components/apps/<app_id>/auth.env
+
+	// Get the path to the auth.env file
+	edgeappAuthEnvPath := "/home/system/components/apps/" + appID + "/auth.env"
+
+	// If the file does not exist, create it
+	if _, err := os.Stat(edgeappAuthEnvPath); os.IsNotExist(err) {
+		// Create the file
+		_, err := os.Create(edgeappAuthEnvPath)
+		if err != nil {
+			log.Printf("Error creating auth.env file: %s", err)
+		}
+	}
+
+	// It is an env file, so we can use go-dotenv to write the options
+	// Open the file
+	edgeappAuthEnvFile, err := os.OpenFile(edgeappAuthEnvPath, os.O_WRONLY, 0600)
+	if err != nil {
+		log.Printf("Error opening auth.env file: %s", err)
+	}
+
+	// Write the login values to the file
+	_, err = edgeappAuthEnvFile.WriteString("USERNAME=" + args.Login.Username + "\n" + "PASSWORD=" + args.Login.Password + "\n")
+	if err != nil {
+		log.Printf("Error writing credentials to auth.env file: %s", err)
+	}
+	
+	// Close the file
+	err = edgeappAuthEnvFile.Close()
+	if err != nil {
+		log.Printf("Error closing auth.env file: %s", err)
+	}
+
+	result := edgeapps.GetEdgeAppStatus(appID)
+	resultJSON, _ := json.Marshal(result)
+
+	system.StartWs()
+	taskGetEdgeApps() // This task will imediatelly update the entry in the api database.
+
+	return string(resultJSON)
+}
+
+func taskRemoveEdgeAppBasicAuth(args taskRemoveEdgeAppBasicAuthArgs) string {
+	// Id is the edgeapp id
+	appID := args.ID
+
+	// Get the path to the auth.env file
+	edgeappAuthEnvFile := "/auth.env"
+
+	fmt.Println("Removing auth.env file" + edgeappAuthEnvFile)
+
+	err := os.Remove(utils.GetPath(utils.EdgeAppsPath) + args.ID + edgeappAuthEnvFile)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	result := edgeapps.GetEdgeAppStatus(appID)
+	resultJSON, _ := json.Marshal(result)
+
+	system.StartWs()
+	taskGetEdgeApps() // This task will imediatelly update the entry in the api database.
+
+	return string(resultJSON)
+}
+
 func taskEnableOnline(args taskEnableOnlineArgs) string {
 	fmt.Println("Executing taskEnableOnline for " + args.ID)
 
@@ -954,6 +1147,35 @@ func taskSetReleaseVersion() string {
 	return diagnostics.Version
 }
 
+func taskUpdateSystemLoggerServices() string {
+	fmt.Println("Executing taskUpdateSystemLoggerServices")
+	// The input is an array of strings
+	// Each string is a service name to be logged
+	var input []string
+
+	// Get the services
+	edgeAppsList := utils.ReadOption("EDGEAPPS_LIST")
+	var edgeApps []edgeapps.EdgeApp
+	err := json.Unmarshal([]byte(edgeAppsList), &edgeApps)
+	if err != nil {
+		log.Fatalf("failed to unmarshal EDGEAPPS_LIST: %v", err)
+	}
+
+	for _, edgeApp := range edgeApps {
+		for _, service := range edgeApp.Services {
+			input = append(input, service.ID)
+		}
+	}
+
+	input = append(input, "edgeboxctl")
+	input = append(input, "tunnel")
+	
+	// Run the system logger
+	system.UpdateSystemLoggerServices(input)
+
+	return "{\"status\": \"ok\"}"
+}
+
 func taskGetEdgeApps() string {
 	fmt.Println("Executing taskGetEdgeApps")
 
@@ -1000,3 +1222,8 @@ func taskSetupCloudOptions() {
 	fmt.Println("Executing taskSetupCloudOptions")
 	system.SetupCloudOptions()
 }
+
+func taskStartWs() {
+	fmt.Println("Executing taskStartWs")
+	system.StartWs()
+}

internal/utils/utils.go

@@ -111,6 +111,8 @@ const ApiPath string = "apiPath"
 const EdgeAppsPath string = "edgeAppsPath"
 const EdgeAppsBackupPath string = "edgeAppsBackupPath"
 const WsPath string = "wsPath"
+const LoggerPath string = "loggerPath"
+
 
 // GetPath : Returns either the hardcoded path, or a overwritten value via .env file at project root. Register paths here for seamless working code between dev and prod environments ;)
 func GetPath(pathKey string) string {
@@ -130,7 +132,7 @@ func GetPath(pathKey string) string {
 		if env["CLOUD_ENV_FILE_LOCATION"] != "" {
 			targetPath = env["CLOUD_ENV_FILE_LOCATION"]
 		} else {
-			targetPath = "/home/system/components/edgeboxctl/cloud.env"
+			targetPath = "/home/system/components/api/cloud.env"
 		}
 
 	case ApiEnvFileLocation:
@@ -172,6 +174,13 @@ func GetPath(pathKey string) string {
 			targetPath = "/home/system/components/ws/"
 		}
 
+	case LoggerPath:
+		if env["LOGGER_PATH"] != "" {
+			targetPath = env["LOGGER_PATH"]
+		} else {
+			targetPath = "/home/system/components/logger/"
+		}
+
 	case BackupPasswordFileLocation:
 
 		if env["BACKUP_PASSWORD_FILE_LOCATION"] != "" {