Fix tests

.github/workflows/go.yml

@@ -17,7 +17,7 @@ jobs:
       with:
         go-version: '1.20.2'
     - name: Check out code
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
     - name: Build
       run: make build
     - name: Test

Makefile

@@ -9,25 +9,10 @@ GOOS := $(shell go env GOOS)
 GOARCH := $(shell go env GOARCH)
 
 
-build-all:
+build-all: clean
 	GOOS=linux GOARCH=amd64 make build
 	GOOS=linux GOARCH=arm make build
-
+	GOOS=linux GOARCH=arm64 make build
-build-prod:
-	GOOS=linux GOARCH=arm RELEASE=prod make build
-
-build-cloud:
-	GOOS=linux GOARCH=amd64 RELEASE=cloud make build
-
-build-arm64:
-	GOOS=linux GOARCH=arm64 RELEASE=prod make build
-
-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}"
@@ -57,11 +42,7 @@ install:
 	@echo "Edgeboxctl installed successfully"
 	@echo "To start edgeboxctl run: systemctl start edgeboxctl"
 
-install-prod: build-prod install
+build-install: build 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
@@ -69,8 +50,5 @@ start:
 stop:
 	systemctl stop edgeboxctl
 
-status:
-	systemctl status edgeboxctl
-
 log: start
 	journalctl -fu edgeboxctl

internal/diagnostics/diagnostics.go

@@ -1,18 +1,5 @@
 package diagnostics
 
-type ReleaseVersion string
-
 var Version string
 var Commit string
 var BuildDate string
-
-const (
-	DEV_VERSION   ReleaseVersion = "dev"
-	PROD_VERSION  ReleaseVersion = "prod"
-	CLOUD_VERSION ReleaseVersion = "cloud"
-	OTHER_VERSION ReleaseVersion = "other"
-)
-
-func GetReleaseVersion() ReleaseVersion {
-	return ReleaseVersion(Version)
-}

internal/edgeapps/edgeapps.go

@@ -11,7 +11,6 @@ import (
 
 	"github.com/edgebox-iot/edgeboxctl/internal/system"
 	"github.com/edgebox-iot/edgeboxctl/internal/utils"
-	"github.com/edgebox-iot/edgeboxctl/internal/diagnostics"
 )
 
 // EdgeApp : Struct representing an EdgeApp in the system
@@ -19,7 +18,6 @@ type EdgeApp struct {
 	ID                 string           `json:"id"`
 	Name               string           `json:"name"`
 	Description        string           `json:"description"`
-	Experimental	   bool             `json:"experimental"`
 	Status             EdgeAppStatus    `json:"status"`
 	Services           []EdgeAppService `json:"services"`
 	InternetAccessible bool             `json:"internet_accessible"`
@@ -88,7 +86,6 @@ func GetEdgeApp(ID string) MaybeEdgeApp {
 
 		edgeAppName := ID
 		edgeAppDescription := ""
-		edgeAppExperimental := false
 		edgeAppOptions := []EdgeAppOption{}
 
 		edgeAppEnv, err := godotenv.Read(utils.GetPath(utils.EdgeAppsPath) + ID + envFilename)
@@ -102,9 +99,6 @@ func GetEdgeApp(ID string) MaybeEdgeApp {
 			if edgeAppEnv["EDGEAPP_DESCRIPTION"] != "" {
 				edgeAppDescription = edgeAppEnv["EDGEAPP_DESCRIPTION"]
 			}
-			if edgeAppEnv["EDGEAPP_EXPERIMENTAL"] == "true" {
-				edgeAppExperimental = true
-			}
 		}
 
 		needsConfig := false
@@ -237,7 +231,6 @@ func GetEdgeApp(ID string) MaybeEdgeApp {
 				ID:                 ID,
 				Name:               edgeAppName,
 				Description:        edgeAppDescription,
-				Experimental:       edgeAppExperimental,
 				Status:             GetEdgeAppStatus(ID),
 				Services:           GetEdgeAppServices(ID),
 				InternetAccessible: edgeAppInternetAccessible,
@@ -270,54 +263,22 @@ func IsEdgeAppInstalled(ID string) bool {
 
 }
 
-func writeAppRunnableFiles(ID string) bool {
-	edgeAppPath := utils.GetPath(utils.EdgeAppsPath)
-	_, err := os.Stat(edgeAppPath + ID + runnableFilename)
-	if os.IsNotExist(err) {
-		_, err := os.Create(edgeAppPath + ID + runnableFilename)
-		if err != nil {
-			log.Fatal("Runnable file for EdgeApp could not be created!")
-			return false
-		}
-
-		// Check the block default apps option
-        blockDefaultAppsOption := utils.ReadOption("DASHBOARD_BLOCK_DEFAULT_APPS_PUBLIC_ACCESS")
-        if blockDefaultAppsOption != "yes" {
-            // Create myedgeapp.env file with default network URL
-            envFilePath := edgeAppPath + ID + myEdgeAppServiceEnvFilename
-            
-			var networkURL string
-			domainName := utils.ReadOption("DOMAIN_NAME")
-
-			if domainName != "" {
-				networkURL = ID + "." + domainName
-			} else if diagnostics.GetReleaseVersion() == diagnostics.CLOUD_VERSION {
-				cluster := utils.ReadOption("CLUSTER") 
-				username := utils.ReadOption("USERNAME")
-				if cluster != "" && username != "" {
-					networkURL = username + "-" + ID + "." + cluster
-				}
-			} else {
-				networkURL = ID + "." + system.GetHostname() + ".local" // default 
-			}
-			
-            env, _ := godotenv.Unmarshal("INTERNET_URL=" + networkURL)
-            err = godotenv.Write(env, envFilePath)
-            if err != nil {
-                log.Printf("Error creating myedgeapp.env file: %s", err)
-                // result = false
-            }
-        }
-	}
-	return true
-}
-
 func SetEdgeAppInstalled(ID string) bool {
 
 	result := true
+	edgeAppPath := utils.GetPath(utils.EdgeAppsPath)
+
+	_, err := os.Stat(edgeAppPath + ID + runnableFilename)
+	if os.IsNotExist(err) {
+
+		_, err := os.Create(edgeAppPath + ID + runnableFilename)
+		result = true
+
+		if err != nil {
+			log.Fatal("Runnable file for EdgeApp could not be created!")
+			result = false
+		}
 
-	if writeAppRunnableFiles(ID) {
-		
 		buildFrameworkContainers()
 
 	} else {
@@ -331,21 +292,6 @@ func SetEdgeAppInstalled(ID string) bool {
 
 }
 
-func SetEdgeAppBulkInstalled(IDs []string) bool {
-
-	result := true
-
-	for _, ID := range IDs {
-		writeAppRunnableFiles(ID)
-	}
-
-	buildFrameworkContainers()
-
-	return result
-
-}
-
-
 func SetEdgeAppNotInstalled(ID string) bool {
 
 	// Stop the app first
@@ -470,24 +416,12 @@ func GetEdgeAppServices(ID string) []EdgeAppService {
 	var edgeAppServices []EdgeAppService
 
 	for _, serviceID := range serviceSlices {
-		shouldBeRunning := false
+		cmdArgs = []string{"-f", wsPath + "/docker-compose.yml", "exec", "-T", serviceID, "echo", "'Service Check'"}
+		cmdResult := utils.Exec(wsPath, "docker-compose", cmdArgs)
 		isRunning := false
-
+		if cmdResult != "" {
-		// Is service "runnable" when .run lockfile in the app folder
+			isRunning = true
-		_, err := os.Stat(utils.GetPath(utils.EdgeAppsPath) + ID + runnableFilename)
-		if !os.IsNotExist(err) {
-			shouldBeRunning = true
 		}
-
-		// Check if the service is actually running
-		if shouldBeRunning {
-			cmdArgs = []string{"-f", wsPath + "/docker-compose.yml", "exec", "-T", serviceID, "echo", "'Service Check'"}
-			cmdResult := utils.Exec(wsPath, "docker-compose", cmdArgs)
-			if cmdResult != "" {
-				isRunning = true
-			}
-		}
-
 		edgeAppServices = append(edgeAppServices, EdgeAppService{ID: serviceID, IsRunning: isRunning})
 	}
 

internal/storage/storage.go

@@ -2,12 +2,10 @@ package storage
 
 import (
 	"fmt"
-	"strconv"
 	"os"
 	"path/filepath"
 	"strings"
 
-	"github.com/edgebox-iot/edgeboxctl/internal/diagnostics"
 	"github.com/edgebox-iot/edgeboxctl/internal/utils"
 	"github.com/shirou/gopsutil/disk"
 )
@@ -74,23 +72,11 @@ const (
 	DISK_TYPE_SDA   DeviceIdentifier = "sda"
 	DISK_TYPE_MCBLK DeviceIdentifier = "mmcblk0"
 	DISK_TYPE_VDA   DeviceIdentifier = "vda"
-	MIN_DISK_SIZE   int              = 1048576 // 1GB in bytes
 )
 
-func GetDeviceIdentifier(release_version diagnostics.ReleaseVersion) DeviceIdentifier {
-	switch release_version {
-	case diagnostics.CLOUD_VERSION:
-		return DISK_TYPE_SDA
-	case diagnostics.PROD_VERSION:
-		return DISK_TYPE_MCBLK
-	}
-
-	return DISK_TYPE_SDA
-}
-
-// GetDevices : Returns a list of all available sotrage devices in structs filled with information
-func GetDevices(release_version diagnostics.ReleaseVersion) []Device {
 
+// GetDevices : Returns a list of all available storage devices in structs filled with information
+func GetDevices() []Device {
 	var devices []Device
 
 	cmdArgs := []string{"--raw", "--bytes", "--noheadings"}
@@ -102,8 +88,6 @@ func GetDevices(release_version diagnostics.ReleaseVersion) []Device {
 	firstDevice := true
 	currentDeviceInUseFlag := false
 
-	mainDiskID := GetDeviceIdentifier(release_version)
-
 	for scanner.Scan() {
 		// 1 Device is represented here. Extract words in order for filling a Device struct
 		// Example deviceRawInfo: "mmcblk0 179:0 0 29.7G 0 disk"
@@ -136,13 +120,7 @@ func GetDevices(release_version diagnostics.ReleaseVersion) []Device {
 				currentDevice.InUse = currentDeviceInUseFlag
 				currentDeviceInUseFlag = false
 				currentPartitions = []Partition{}
-				size, err := strconv.Atoi(currentDevice.Size)
+				devices = append(devices, currentDevice)
-				if err != nil {
-					size = 0
-				}
-				if size > MIN_DISK_SIZE {
-					devices = append(devices, currentDevice)
-				}
 			} else {
 				firstDevice = false
 			}
@@ -161,14 +139,9 @@ func GetDevices(release_version diagnostics.ReleaseVersion) []Device {
 				Status:     DeviceStatus{ID: 1, Description: "healthy"},
 			}
 
-			if device.ID == mainDiskID {
-				device.MainDevice = true
-			}
-
 			currentDevice = device
 
 		} else if isPartition {
-
 			mountpoint := ""
 			if len(deviceRawInfo) >= 7 {
 				mountpoint = deviceRawInfo[6]
@@ -201,22 +174,8 @@ func GetDevices(release_version diagnostics.ReleaseVersion) []Device {
 		currentDevice.Status.Description = "Not configured"
 	}
 	currentDevice.InUse = currentDeviceInUseFlag
+	devices = append([]Device{currentDevice}, devices...) // Prepending the first device...
 
-	fmt.Println("Secondary Storage Devices Found: ", len(devices))
-	fmt.Println("Main Storage Device size: ", currentDevice.Size)
-
-	// only append device if size > 1GB
-	if currentDevice.Size != "" && currentDevice.Size != "0" {
-		// Convert size to int
-		// Convert string to int
-		size, err := strconv.Atoi(currentDevice.Size)
-		if err != nil {
-			size = 0
-		}
-		if size > MIN_DISK_SIZE {
-			devices = append([]Device{currentDevice}, devices...) // Prepending the first device...
-		}
-	}
 	devices = getDevicesSpaceUsage(devices)
 
 	return devices

internal/storage/storage_test.go

@@ -7,14 +7,7 @@ import (
 )
 
 func TestGetDevices(t *testing.T) {
-
+	assertGetDevices(GetDevices(), t)
-	t.Log("Testing with release version dev")
-	assertGetDevices(GetDevices("dev"), t)
-	t.Log("Testing with release version prod")
-	assertGetDevices(GetDevices("prod"), t)
-	t.Log("Testing with release version cloud")
-	assertGetDevices(GetDevices("cloud"), t)
-
 }
 
 func assertGetDevices(devices []Device, t *testing.T) {

internal/system/system.go

@@ -82,6 +82,7 @@ func SetupCloudOptions() {
 
 	if err != nil {
 		fmt.Println("Error loading .env file for cloud version setup")
+		return
 	}
 
 	if cloudEnv["NAME"] != "" {
@@ -425,94 +426,3 @@ func CopyFile(src string, dest string) error {
     return nil
 }
 
-func CheckUpdates() {
-	fmt.Println("Checking for Edgebox System Updates.")
-	
-	// Configure the service and start it
-	cmd := exec.Command("sh", "/home/system/components/updater/run.sh", "--check")
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		panic(err)
-	}
-	scanner := bufio.NewScanner(stdout)
-	err = cmd.Start()
-	if err != nil {
-		panic(err)
-	}
-	for scanner.Scan() {
-		// fmt.Println(scanner.Text())
-		text := scanner.Text()
-		fmt.Println(text)
-	}
-	if scanner.Err() != nil {
-		cmd.Process.Kill()
-		cmd.Wait()
-		fmt.Println("Error running updates check.")
-		utils.WriteOption("SYSTEM_UPDATES", "[]")
-		return
-	}
-
-	// Read targets.env file into JSON list structure
-	targets := []string{}
-	targetsFile, err := os.Open("/home/system/components/updater/targets.env")
-	if err != nil {
-		fmt.Println("No targets.env file found. Skipping.")
-		utils.WriteOption("SYSTEM_UPDATES", "[]")
-		return
-	}
-	defer targetsFile.Close()
-	scanner = bufio.NewScanner(targetsFile)
-	for scanner.Scan() {
-		text := scanner.Text()
-		// text line should look like: {"target": "<target>", "version": "<version>"}
-		target := strings.Split(text, "=")
-		newText := "{\"target\": \"" + strings.Replace(target[0], "_VERSION", "", -1) + "\", \"version\": \"" + target[1] + "\"}"
-		targets = append(targets, newText)
-	}
-	if scanner.Err() != nil {
-		fmt.Println("Error reading update targets file.")
-		utils.WriteOption("SYSTEM_UPDATES", "[]")
-		return
-	}
-
-	// convert targets to string
-	targetsString := strings.Join(targets, ",")
-	targetsString = "[" + targetsString + "]"
-
-	fmt.Println(targetsString)
-
-	// Write option with targets
-	utils.WriteOption("SYSTEM_UPDATES", targetsString)
-}
-
-func ApplyUpdates() {
-	fmt.Println("Applying Edgebox System Updates.")
-
-	utils.WriteOption("UPDATING_SYSTEM", "true")
-	
-	// Configure the service and start it
-	cmd := exec.Command("sh", "/home/system/components/updater/run.sh", "--update")
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		panic(err)
-	}
-	scanner := bufio.NewScanner(stdout)
-	err = cmd.Start()
-	if err != nil {
-		panic(err)
-	}
-	for scanner.Scan() {
-		fmt.Println(scanner.Text())
-		text := scanner.Text()
-		fmt.Println(text)
-	}
-	if scanner.Err() != nil {
-		cmd.Process.Kill()
-		cmd.Wait()
-		panic(scanner.Err())
-	}
-
-	// If the system did not yet restart, set updating system to false
-	utils.WriteOption("UPDATING_SYSTEM", "false")
-}
-

internal/tasks/tasks.go

@@ -56,10 +56,6 @@ type taskInstallEdgeAppArgs struct {
 	ID string `json:"id"`
 }
 
-type taskInstallBulkEdgeAppsArgs struct {
-	IDS []string `json:"ids"`
-}
-
 type taskRemoveEdgeAppArgs struct {
 	ID string `json:"id"`
 }
@@ -104,10 +100,6 @@ type taskSetupBackupsArgs struct {
 	RepositoryPassword string `json:"repository_password"`
 }
 
-type taskStartShellArgs struct {
-	Timeout int `json:"timeout"`
-}
-
 
 const STATUS_CREATED int = 0
 const STATUS_EXECUTING int = 1
@@ -150,33 +142,6 @@ func GetNextTask() Task {
 
 }
 
-// GetExecutingTasks : Performs a MySQL query over the device's Edgebox API to obtain all tasks that are currently executing
-func GetExecutingTasks() []Task {
-	// Will try to connect to API database, which should be running locally under WS.
-	db, err := sql.Open("sqlite3", utils.GetSQLiteDbConnectionDetails())
-	if err != nil {
-		panic(err.Error())
-	}
-	results, err := db.Query("SELECT id, task, args, status, result, created, updated FROM task WHERE status = 1;")
-	if err != nil {
-		panic(err.Error())
-	}
-
-	var tasks []Task
-	for results.Next() {
-		// for each row, scan the result into our task composite object
-		var task Task
-		err = results.Scan(&task.ID, &task.Task, &task.Args, &task.Status, &task.Result, &task.Created, &task.Updated)
-		if err != nil {
-			panic(err.Error()) // proper error handling instead of panic in your app
-		}
-		tasks = append(tasks, task)
-	}
-	results.Close()
-	db.Close()
-	return tasks
-}
-
 // ExecuteTask : Performs execution of the given task, updating the task status as it goes, and publishing the task result
 func ExecuteTask(task Task) Task {
 
@@ -199,260 +164,208 @@ func ExecuteTask(task Task) Task {
 		log.Fatal(err.Error())
 	}
 
-	if diagnostics.GetReleaseVersion() == diagnostics.DEV_VERSION {
+	log.Println("Task: " + task.Task)
-		log.Printf("Dev environemnt. Not executing tasks.")
+	log.Println("Args: " + task.Args.String)
-	} else {
+	switch task.Task {
-		log.Println("Task: " + task.Task)
+	case "setup_backups":
-		log.Println("Args: " + task.Args.String)
-		switch task.Task {
-		case "setup_backups":
 
-			log.Println("Setting up Backups Destination...")
+		log.Println("Setting up Backups Destination...")
-			var args taskSetupBackupsArgs
+		var args taskSetupBackupsArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
+		err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
+		if err != nil {
-				log.Println("Error reading arguments of setup_backups task.")
+			log.Println("Error reading arguments of setup_backups task.")
-			} else {
+		} else {
-				taskResult := taskSetupBackups(args)
+			taskResult := taskSetupBackups(args)
-				taskResultBool := true
-				// Check if returned taskResult string contains "error"
-				if strings.Contains(taskResult, "error") {
-					taskResultBool = false
-				}
-				task.Result = sql.NullString{String: taskResult, Valid: taskResultBool}
-			}
-
-		case "start_backup":
-
-			log.Println("Backing up Edgebox...")
-			taskResult := taskBackup()
 			taskResultBool := true
 			// Check if returned taskResult string contains "error"
 			if strings.Contains(taskResult, "error") {
 				taskResultBool = false
 			}
 			task.Result = sql.NullString{String: taskResult, Valid: taskResultBool}
-
-		case "restore_backup":
-			log.Println("Attempting to Restore Last Backup to Edgebox")
-			taskResult := taskRestoreBackup()
-			taskResultBool := true
-			// Check if returned taskResult string contains "error"
-			if strings.Contains(taskResult, "error") {
-				taskResultBool = false
-			}
-			task.Result = sql.NullString{String: taskResult, Valid: taskResultBool}
-
-		case "setup_tunnel":
-
-			log.Println("Setting up Cloudflare Tunnel...")
-			var args taskSetupTunnelArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of setup_tunnel task: %s", err)
-				status := "{\"status\": \"error\", \"message\": \"The Domain Name you are going to Authorize must be provided beforehand! Please insert a domain name and try again.\"}"
-				utils.WriteOption("TUNNEL_STATUS", status)
-			} else {
-				taskResult := taskSetupTunnel(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
-		case "start_tunnel":
-
-			log.Println("Starting Cloudflare Tunnel...")
-			taskResult := taskStartTunnel()
-			task.Result = sql.NullString{String: taskResult, Valid: true}
-
-		case "stop_tunnel":
-
-			log.Println("Stopping Cloudflare Tunnel...")
-			taskResult := taskStopTunnel()
-			task.Result = sql.NullString{String: taskResult, Valid: true}
-		
-		case "disable_tunnel":
-
-			log.Println("Disabling Cloudflare Tunnel...")
-			taskResult := taskDisableTunnel()
-			task.Result = sql.NullString{String: taskResult, Valid: true}
-
-		case "start_shell":
-			log.Println("Starting SSHX.io Shell")
-			var args taskStartShellArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments or start_shell task: %s", err)
-			} else {
-				taskResult := taskStartShell(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}												
-			}
-
-		case "stop_shell":
-			log.Println("Stopping SSHX.io Shell...")
-			taskResult := taskStopShell()
-			task.Result = sql.NullString{String: taskResult, Valid: true}
-
-		case "install_edgeapp":
-
-			log.Println("Installing EdgeApp...")
-			var args taskInstallEdgeAppArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of install_edgeapp task: %s", err)
-			} else {
-				taskResult := taskInstallEdgeApp(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
-		case "install_bulk_edgeapps":
-
-			log.Println("Installing Bulk EdgeApps...")
-			var args taskInstallBulkEdgeAppsArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of install_bulk_edgeapps task: %s", err)
-			} else {
-				taskResult := taskInstallBulkEdgeApps(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
-		case "remove_edgeapp":
-
-			log.Println("Removing EdgeApp...")
-			var args taskRemoveEdgeAppArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of remove_edgeapp task: %s", err)
-			} else {
-				taskResult := taskRemoveEdgeApp(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
-		case "start_edgeapp":
-
-			log.Println("Starting EdgeApp...")
-			var args taskStartEdgeAppArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of start_edgeapp task: %s", err)
-			} else {
-				taskResult := taskStartEdgeApp(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
-		case "stop_edgeapp":
-
-			log.Println("Stopping EdgeApp...")
-			var args taskStopEdgeAppArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of stop_edgeapp task: %s", err)
-			} else {
-				taskResult := taskStopEdgeApp(args)
-				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...")
-			var args taskEnableOnlineArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of enable_online task: %s", err)
-			} else {
-				taskResult := taskEnableOnline(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
-		case "disable_online":
-
-			log.Println("Disabling online access to EdgeApp...")
-			var args taskDisableOnlineArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of enable_online task: %s", err)
-			} else {
-				taskResult := taskDisableOnline(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
-		case "enable_public_dashboard":
-
-			log.Println("Enabling online access to Dashboard...")
-			var args taskEnablePublicDashboardArgs
-			err := json.Unmarshal([]byte(task.Args.String), &args)
-			if err != nil {
-				log.Printf("Error reading arguments of enable_public_dashboard task: %s", err)
-			} else {
-				taskResult := taskEnablePublicDashboard(args)
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
-		case "disable_public_dashboard":
-
-			log.Println("Disabling online access to Dashboard...")
-			taskResult := taskDisablePublicDashboard()
-			task.Result = sql.NullString{String: taskResult, Valid: true}
-
-		case "check_updates":
-			log.Println("Checking for updates...")
-			taskResult := taskCheckSystemUpdates()
-			task.Result = sql.NullString{String: taskResult, Valid: true}
-
-		case "apply_updates":
-
-			log.Println("Updating Edgebox System...")
-			is_updating := utils.ReadOption("UPDATING_SYSTEM")
-			if is_updating == "true"  {
-				log.Println("Edgebox update was running... Probably system restarted. Finishing update...")
-				utils.WriteOption("UPDATING_SYSTEM", "false")
-				task.Result = sql.NullString{String: "{result: true}", Valid: true}
-			} else {
-				log.Println("Updating Edgebox System...")
-				taskResult := taskUpdateSystem()
-				task.Result = sql.NullString{String: taskResult, Valid: true}
-			}
-
 		}
 
+	case "start_backup":
+
+		log.Println("Backing up Edgebox...")
+		taskResult := taskBackup()
+		taskResultBool := true
+		// Check if returned taskResult string contains "error"
+		if strings.Contains(taskResult, "error") {
+			taskResultBool = false
+		}
+		task.Result = sql.NullString{String: taskResult, Valid: taskResultBool}
+
+	case "restore_backup":
+		log.Println("Attempting to Restore Last Backup to Edgebox")
+		taskResult := taskRestoreBackup()
+		taskResultBool := true
+		// Check if returned taskResult string contains "error"
+		if strings.Contains(taskResult, "error") {
+			taskResultBool = false
+		}
+		task.Result = sql.NullString{String: taskResult, Valid: taskResultBool}
+
+	case "setup_tunnel":
+
+		log.Println("Setting up Cloudflare Tunnel...")
+		var args taskSetupTunnelArgs
+		err := json.Unmarshal([]byte(task.Args.String), &args)
+		if err != nil {
+			log.Printf("Error reading arguments of setup_tunnel task: %s", err)
+			status := "{\"status\": \"error\", \"message\": \"The Domain Name you are going to Authorize must be provided beforehand! Please insert a domain name and try again.\"}"
+			utils.WriteOption("TUNNEL_STATUS", status)
+		} else {
+			taskResult := taskSetupTunnel(args)
+			task.Result = sql.NullString{String: taskResult, Valid: true}
+		}
+
+	case "start_tunnel":
+
+		log.Println("Starting Cloudflare Tunnel...")
+		taskResult := taskStartTunnel()
+		task.Result = sql.NullString{String: taskResult, Valid: true}
+
+	case "stop_tunnel":
+
+		log.Println("Stopping Cloudflare Tunnel...")
+		taskResult := taskStopTunnel()
+		task.Result = sql.NullString{String: taskResult, Valid: true}
+	
+	case "disable_tunnel":
+
+		log.Println("Disabling Cloudflare Tunnel...")
+		taskResult := taskDisableTunnel()
+		task.Result = sql.NullString{String: taskResult, Valid: true}
+
+	case "install_edgeapp":
+
+		log.Println("Installing EdgeApp...")
+		var args taskInstallEdgeAppArgs
+		err := json.Unmarshal([]byte(task.Args.String), &args)
+		if err != nil {
+			log.Printf("Error reading arguments of install_edgeapp task: %s", err)
+		} else {
+			taskResult := taskInstallEdgeApp(args)
+			task.Result = sql.NullString{String: taskResult, Valid: true}
+		}
+
+	case "remove_edgeapp":
+
+		log.Println("Removing EdgeApp...")
+		var args taskRemoveEdgeAppArgs
+		err := json.Unmarshal([]byte(task.Args.String), &args)
+		if err != nil {
+			log.Printf("Error reading arguments of remove_edgeapp task: %s", err)
+		} else {
+			taskResult := taskRemoveEdgeApp(args)
+			task.Result = sql.NullString{String: taskResult, Valid: true}
+		}
+
+	case "start_edgeapp":
+
+		log.Println("Starting EdgeApp...")
+		var args taskStartEdgeAppArgs
+		err := json.Unmarshal([]byte(task.Args.String), &args)
+		if err != nil {
+			log.Printf("Error reading arguments of start_edgeapp task: %s", err)
+		} else {
+			taskResult := taskStartEdgeApp(args)
+			task.Result = sql.NullString{String: taskResult, Valid: true}
+		}
+
+	case "stop_edgeapp":
+
+		log.Println("Stopping EdgeApp...")
+		var args taskStopEdgeAppArgs
+		err := json.Unmarshal([]byte(task.Args.String), &args)
+		if err != nil {
+			log.Printf("Error reading arguments of stop_edgeapp task: %s", err)
+		} else {
+			taskResult := taskStopEdgeApp(args)
+			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...")
+		var args taskEnableOnlineArgs
+		err := json.Unmarshal([]byte(task.Args.String), &args)
+		if err != nil {
+			log.Printf("Error reading arguments of enable_online task: %s", err)
+		} else {
+			taskResult := taskEnableOnline(args)
+			task.Result = sql.NullString{String: taskResult, Valid: true}
+		}
+
+	case "disable_online":
+
+		log.Println("Disabling online access to EdgeApp...")
+		var args taskDisableOnlineArgs
+		err := json.Unmarshal([]byte(task.Args.String), &args)
+		if err != nil {
+			log.Printf("Error reading arguments of enable_online task: %s", err)
+		} else {
+			taskResult := taskDisableOnline(args)
+			task.Result = sql.NullString{String: taskResult, Valid: true}
+		}
+
+	case "enable_public_dashboard":
+
+		log.Println("Enabling online access to Dashboard...")
+		var args taskEnablePublicDashboardArgs
+		err := json.Unmarshal([]byte(task.Args.String), &args)
+		if err != nil {
+			log.Printf("Error reading arguments of enable_public_dashboard task: %s", err)
+		} else {
+			taskResult := taskEnablePublicDashboard(args)
+			task.Result = sql.NullString{String: taskResult, Valid: true}
+		}
+
+	case "disable_public_dashboard":
+
+		log.Println("Disabling online access to Dashboard...")
+		taskResult := taskDisablePublicDashboard()
+		task.Result = sql.NullString{String: taskResult, Valid: true}
 	}
 
+
 	statement, err = db.Prepare("Update task SET status = ?, result = ?, updated = ? WHERE ID = ?;") // Prepare SQL Statement
 	if err != nil {
 		log.Fatal(err.Error())
@@ -469,7 +382,6 @@ func ExecuteTask(task Task) Task {
 		if err != nil {
 			log.Fatal(err.Error())
 		}
-
 	} else {
 		fmt.Println("Error executing task with result: " + task.Result.String)
 		_, err = statement.Exec(STATUS_ERROR, "Error", formatedDatetime, strconv.Itoa(task.ID)) // Execute SQL Statement with Error info
@@ -510,10 +422,9 @@ func ExecuteSchedules(tick int) {
 		// 	})
 		// }
 
-		if diagnostics.GetReleaseVersion() == diagnostics.CLOUD_VERSION {
+
-			log.Println("Setting up cloud version options (name, email, api token)")
+		log.Println("Setting up cloud version options (name, email, api token)")
-			taskSetupCloudOptions()
+		taskSetupCloudOptions()
-		}
 
 		// Executing on startup (first tick). Schedules run before tasks in the SystemIterator
 		uptime := taskGetSystemUptime()
@@ -523,9 +434,6 @@ func ExecuteSchedules(tick int) {
 		taskStartWs()
 		log.Println(taskGetEdgeApps())
 		taskUpdateSystemLoggerServices()
-		taskRecoverFromUpdate()
-		taskCheckSystemUpdates()
-		
 	}
 
 	if tick%5 == 0 {
@@ -572,7 +480,6 @@ func ExecuteSchedules(tick int) {
 
 	if tick%3600 == 0 {
 		// Executing every 3600 ticks (1 hour)
-		taskCheckSystemUpdates()
 	}
 
 	if tick%86400 == 0 {
@@ -991,19 +898,12 @@ func taskSetupTunnel(args taskSetupTunnelArgs) string {
 }
 
 func taskStartTunnel() string {
-    fmt.Println("Executing taskStartTunnel")
+	fmt.Println("Executing taskStartTunnel")
-    
+	system.StartService("cloudflared")
-    // Read tunnel status to check if cloudflare is configured
+	domainName := utils.ReadOption("DOMAIN_NAME")
-    tunnelStatus := utils.ReadOption("TUNNEL_STATUS")
+	status := "{\"status\": \"connected\", \"domain\": \"" + domainName + "\"}"
-	if tunnelStatus != "" {
+	utils.WriteOption("TUNNEL_STATUS", status)
-		// Only start cloudflared if we have a tunnel configured
+	return "{\"status\": \"ok\"}"
-        system.StartService("cloudflared")
-        domainName := utils.ReadOption("DOMAIN_NAME")
-        status := "{\"status\": \"connected\", \"domain\": \"" + domainName + "\"}"
-        utils.WriteOption("TUNNEL_STATUS", status)
-	}
-    
-    return "{\"status\": \"ok\"}"
 }
 
 func taskStopTunnel() string {
@@ -1025,78 +925,6 @@ func taskDisableTunnel() string {
 	return "{\"status\": \"ok\"}"
 }
 
-func taskStartShell(args taskStartShellArgs) string {
-	fmt.Println("Executing taskStartShell")
-	wsPath := utils.GetPath(utils.WsPath)
-
-	// kill the process if its running
-	utils.Exec(wsPath, "killall", []string{"sshx"})
-
-	cmd := exec.Command("/usr/local/bin/sshx", "--quiet", "--shell", "bash")
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		panic(err)
-	}
-	scanner := bufio.NewScanner(stdout)
-	err = cmd.Start()
-	if err != nil {
-		panic(err)
-	}
-	url := ""
-
-	timeout := args.Timeout
-
-	for scanner.Scan() {
-		fmt.Println(scanner.Text())
-		text := scanner.Text()
-		if strings.Contains(text, "https://") {
-			url = text
-			fmt.Println("Shell start is responding with URL: " + url)
-			utils.WriteOption("SHELL_URL", url)
-			utils.WriteOption("SHELL_STATUS", "running")
-			break
-		}
-	}
-	if scanner.Err() != nil {
-		cmd.Process.Kill()
-		cmd.Wait()
-		panic(scanner.Err())
-	}
-
-	go func() {
-		fmt.Println("Running shell async")
-		
-		// cmd.Wait()
-
-		// Keep retrying to calculate timeout to know when to kill the process
-		for {
-			timeout = timeout - 1
-			if timeout <= 0 {
-				fmt.Println("Timeout reached, killing process...")
-				utils.Exec(wsPath, "killall sshx", []string{})
-				utils.WriteOption("SHELL_STATUS", "not_running")
-				break
-			}
-			fmt.Println("Active Shell Timeout is " + fmt.Sprint(timeout) + " seconds")
-			time.Sleep(1 * time.Second)
-		}
-	}()
-
-	return "{\"status\": \"ok\"}"
-}
-
-func taskStopShell() string {
-	fmt.Println("Executing taskStopShell")
-	wsPath := utils.GetPath(utils.WsPath)
-
-	// kill the process if its running
-	utils.Exec(wsPath, "killall", []string{"sshx"})
-	utils.WriteOption("SHELL_STATUS", "not_running")
-
-	return "{\"status\": \"ok\"}"
-
-}
-
 func taskInstallEdgeApp(args taskInstallEdgeAppArgs) string {
 	fmt.Println("Executing taskInstallEdgeApp for " + args.ID)
 
@@ -1107,16 +935,6 @@ func taskInstallEdgeApp(args taskInstallEdgeAppArgs) string {
 	return string(resultJSON)
 }
 
-func taskInstallBulkEdgeApps(args taskInstallBulkEdgeAppsArgs) string {
-	fmt.Println("Executing taskInstallBulkEdgeApps for " + strings.Join(args.IDS, ", "))
-
-	// args.Apps is a list of edgeapp ids
-	edgeapps.SetEdgeAppBulkInstalled(args.IDS)
-
-	taskGetEdgeApps()
-	return "{\"status\": \"ok\"}"
-}
-
 func taskRemoveEdgeApp(args taskRemoveEdgeAppArgs) string {
 	fmt.Println("Executing taskRemoveEdgeApp for " + args.ID)
 
@@ -1314,39 +1132,6 @@ func taskDisablePublicDashboard() string {
 	return "{result: false}"
 }
 
-func taskCheckSystemUpdates() string {
-	fmt.Println("Executing taskCheckSystemUpdates")
-	system.CheckUpdates()
-	return "{result: true}"
-}
-
-func taskUpdateSystem() string {
-	fmt.Println("Executing taskUpdateSystem")
-	system.ApplyUpdates()
-	utils.WriteOption("LAST_UPDATE", strconv.FormatInt(time.Now().Unix(), 10))
-	return "{result: true}"
-}
-
-func taskRecoverFromUpdate() string {
-	fmt.Println("Executing taskRecoverFromUpdate")
-	executing_tasks := GetExecutingTasks()
-	// Filter out the task with task value "update_system"
-	filteredTasks := []Task{}
-	for _, task := range executing_tasks {
-		if task.Task != "update_system" {
-			filteredTasks = append(filteredTasks, task)
-		}
-	}
-	
-	// If tasks is not empty, Get the last task
-	if len(filteredTasks) > 0 {
-		lastTask := filteredTasks[len(filteredTasks)-1]
-		ExecuteTask(lastTask)
-	}
-
-	return "{result: true}"
-}
-
 func taskSetReleaseVersion() string {
 
 	fmt.Println("Executing taskSetReleaseVersion")
@@ -1405,7 +1190,7 @@ func taskGetSystemUptime() string {
 func taskGetStorageDevices() string {
 	fmt.Println("Executing taskGetStorageDevices")
 
-	devices := storage.GetDevices(diagnostics.GetReleaseVersion())
+	devices := storage.GetDevices()
 	devicesJSON, _ := json.Marshal(devices)
 
 	utils.WriteOption("STORAGE_DEVICES_LIST", string(devicesJSON))