Add ready_fd service field

Reviewed-on: #1

Makefile

@@ -23,9 +23,9 @@ endif
 
 build:
 	mkdir -p build
-	cd cmd/enit; $(GO) build -ldflags "-w -X main.version=$(VERSION)" -o ../../build/enit enit
-	cd cmd/esvm; $(GO) build -ldflags "-w -X main.version=$(VERSION)" -o ../../build/esvm esvm
-	cd cmd/ectl; $(GO) build -ldflags "-w -X main.version=$(VERSION) -X main.sysconfdir=$(SYSCONFDIR) -X main.runstatedir=$(RUNSTATEDIR)" -o ../../build/ectl ectl
+	cd src/enit; $(GO) build -ldflags "-w -X main.version=$(VERSION)" -o ../../build/enit enit
+	cd src/esvm; $(GO) build -ldflags "-w -X main.version=$(VERSION)" -o ../../build/esvm esvm
+	cd src/ectl; $(GO) build -ldflags "-w -X main.version=$(VERSION) -X main.sysconfdir=$(SYSCONFDIR) -X main.runstatedir=$(RUNSTATEDIR)" -o ../../build/ectl ectl
 
 install: build/enit build/ectl
 	mkdir -p $(DESTDIR)$(SBINDIR)

cmd/ectl/go.mod

@@ -1,5 +0,0 @@
-module ectl
-
-go 1.23.4
-
-require gopkg.in/yaml.v3 v3.0.1

cmd/ectl/main.go

@@ -1,340 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"gopkg.in/yaml.v3"
-	"log"
-	"net"
-	"os"
-	"path"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-)
-
-// Build-time variables
-var version = "dev"
-var sysconfdir = "/etc/"
-var runstatedir = "/var/run/"
-
-var socket net.Conn
-
-func main() {
-
-	// Set and parse flags
-	printVersion := flag.Bool("version", false, "print version and exit")
-	flag.Parse()
-
-	// Dial esvm socket
-	dialSocket()
-	defer socket.Close()
-
-	if flag.NArg() < 1 {
-		printUsage()
-		os.Exit(1)
-	}
-
-	if *printVersion || flag.Args()[0] == "version" {
-		fmt.Printf("Enit Control version %s\n", version)
-		return
-	} else if flag.Args()[0] == "help" {
-		printUsage()
-		return
-	} else if flag.Args()[0] == "shutdown" || flag.Args()[0] == "poweroff" || flag.Args()[0] == "halt" {
-		err := syscall.Kill(1, syscall.SIGUSR1)
-		if err != nil {
-			log.Fatalf("Could not send shutdown signal! Error: %s\n", err)
-		}
-		return
-	} else if flag.Args()[0] == "reboot" || flag.Args()[0] == "restart" || flag.Args()[0] == "reset" {
-		err := syscall.Kill(1, syscall.SIGTERM)
-		if err != nil {
-			log.Fatalf("Could not send shutdown signal! Error: %s\n", err)
-		}
-		return
-	} else if flag.Args()[0] == "service" || flag.Args()[0] == "sv" {
-		if len(flag.Args()) <= 1 {
-			fmt.Println("Usage: ectl service <start/stop/enable/disable/status/list> [service]")
-			return
-		} else if flag.Args()[1] == "list" {
-			if _, err := os.Stat(path.Join(runstatedir, "esvm")); err != nil {
-				log.Fatalf("Could not list services! Error: %s\n", err)
-			}
-
-			entries, err := os.ReadDir(path.Join(runstatedir, "esvm"))
-			if err != nil {
-				log.Fatalf("Could not list services! Error: %s\n", err)
-			}
-
-			for _, entry := range entries {
-				if !entry.IsDir() {
-					continue
-				}
-
-				state := getServiceState(entry.Name())
-				enabled := strconv.FormatBool(isServiceEnabled(entry.Name()))
-				enabled = strings.ToUpper(enabled[:1]) + strings.ToLower(enabled[1:])
-
-				fmt.Println("Service name: " + entry.Name())
-				fmt.Printf("    State: %s\n", state)
-				fmt.Printf("    Enabled: %s\n", enabled)
-			}
-			return
-		} else if len(flag.Args()) <= 2 {
-			fmt.Printf("Usage: ectl service %s <service>\n", flag.Args()[1])
-			return
-		} else if flag.Args()[1] == "start" {
-			if _, err := os.Stat(path.Join(runstatedir, "esvm", flag.Args()[2])); err != nil {
-				log.Fatalf("Could not start service! Error: %s\n", err)
-			}
-
-			_, err := socket.Write([]byte("start " + flag.Args()[2]))
-			if err != nil {
-				log.Fatalf("Could not start service! Error: %s\n", err)
-			}
-
-			buf := make([]byte, 1024)
-			n, err := socket.Read(buf)
-			if err != nil {
-				log.Fatalf("Could not start service! Error: %s\n", err)
-			}
-			if string(buf[:n]) != "ok" {
-				log.Fatalf("Could not start service! Error: expcted 'ok' got '%s'\n", string(buf))
-			}
-
-			fmt.Println("Service started successfully!")
-			return
-		} else if flag.Args()[1] == "stop" {
-			if _, err := os.Stat(path.Join(runstatedir, "esvm", flag.Args()[2])); err != nil {
-				log.Fatalf("Could not stop service! Error: %s\n", err)
-			}
-
-			_, err := socket.Write([]byte("stop " + flag.Args()[2]))
-			if err != nil {
-				log.Fatalf("Could not stop service! Error: %s\n", err)
-			}
-
-			buf := make([]byte, 1024)
-			n, err := socket.Read(buf)
-			if err != nil {
-				log.Fatalf("Could not stop service! Error: %s\n", err)
-			}
-			if string(buf[:n]) != "ok" {
-				log.Fatalf("Could not stop service! Error: expcted 'ok' got '%s'\n", string(buf))
-			}
-			fmt.Println("Service stopped successfully!")
-			return
-		} else if flag.Args()[1] == "restart" || flag.Args()[1] == "reload" {
-			if _, err := os.Stat(path.Join(runstatedir, "esvm", flag.Args()[2])); err != nil {
-				log.Fatalf("Could not restart service! Error: %s\n", err)
-			}
-
-			_, err := socket.Write([]byte("restart " + flag.Args()[2]))
-			if err != nil {
-				log.Fatalf("Could not restart service! Error: %s\n", err)
-			}
-
-			buf := make([]byte, 1024)
-			n, err := socket.Read(buf)
-			if err != nil {
-				log.Fatalf("Could not restart service! Error: %s\n", err)
-			}
-			if string(buf[:n]) != "ok" {
-				log.Fatalf("Could not restart service! Error: expcted 'ok' got '%s'\n", string(buf))
-			}
-			fmt.Println("Service restarted successfully!")
-			return
-		} else if flag.Args()[1] == "enable" {
-			// Check if service exists
-			found := false
-			entries, err := os.ReadDir(path.Join(sysconfdir, "esvm/services/"))
-			if err != nil {
-				log.Fatalf("Could not enable service! Error: %s\n", err)
-			}
-			type minimalServiceStruct struct {
-				Name string `yaml:"name"`
-			}
-			for _, entry := range entries {
-				if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".esv") {
-					continue
-				}
-
-				bytes, err := os.ReadFile(path.Join(sysconfdir, "esvm/services", entry.Name()))
-				if err != nil {
-					log.Fatalf("Could not enable service! Error: %s\n", err)
-				}
-
-				sv := minimalServiceStruct{Name: ""}
-				err = yaml.Unmarshal(bytes, &sv)
-				if err != nil {
-					log.Fatalf("Could not enable service! Error: %s\n", err)
-				}
-
-				if sv.Name == flag.Args()[2] {
-					found = true
-					break
-				}
-			}
-			if !found {
-				log.Fatalf("Service does not exist!")
-			}
-
-			if _, err := os.Stat(path.Join(sysconfdir, "esvm/enabled_services")); err != nil {
-				err := os.WriteFile(path.Join(sysconfdir, "esvm/enabled_services"), []byte(flag.Args()[2]+"\n"), 0644)
-				if err != nil {
-					log.Fatalf("Could not enable service! Error: %s\n", err)
-				}
-				return
-			}
-
-			file, err := os.ReadFile(path.Join(sysconfdir, "esvm/enabled_services"))
-			if err != nil {
-				log.Fatalf("Could not enable service! Error: %s\n", err)
-			}
-			for _, line := range strings.Split(string(file), "\n") {
-				if strings.TrimSpace(line) == flag.Args()[2] {
-					fmt.Println("Service is already enabled!")
-					return
-				}
-			}
-
-			err = os.WriteFile(path.Join(sysconfdir, "esvm/enabled_services"), []byte(string(file)+flag.Args()[2]+"\n"), 0644)
-			if err != nil {
-				log.Fatalf("Could not enable service! Error: %s\n", err)
-			}
-
-			fmt.Printf("Service (%s) has been enabled!\n", flag.Args()[2])
-			return
-		} else if flag.Args()[1] == "disable" {
-			if _, err := os.Stat(path.Join(sysconfdir, "esvm/enabled_services")); err != nil {
-				fmt.Println("Service is already disabled!")
-				return
-			}
-
-			file, err := os.ReadFile(path.Join(sysconfdir, "esvm/enabled_services"))
-			if err != nil {
-				log.Fatalf("Could not disable service! Error: %s\n", err)
-			}
-
-			lines := strings.Split(string(file), "\n")
-			found := false
-			for i := len(lines) - 1; i >= 0; i-- {
-				line := strings.TrimSpace(lines[i])
-				if strings.TrimSpace(line) == flag.Args()[2] {
-					lines = append(lines[:i], lines[i+1:]...)
-					found = true
-				} else if strings.TrimSpace(line) == "" {
-					lines = append(lines[:i], lines[i+1:]...)
-				}
-			}
-
-			if !found {
-				fmt.Println("Service is already disabled!")
-				return
-			}
-
-			err = os.WriteFile(path.Join(sysconfdir, "esvm/enabled_services"), []byte(strings.Join(lines, "\n")+"\n"), 0644)
-			if err != nil {
-				log.Fatalf("Could not disable service! Error: %s\n", err)
-			}
-
-			fmt.Printf("Service (%s) has been disabled!\n", flag.Args()[2])
-			return
-		} else if flag.Args()[1] == "status" {
-			if _, err := os.Stat(path.Join(runstatedir, "esvm", flag.Args()[2])); err != nil {
-				log.Fatalf("Could not get service status! Error: %s\n", err)
-			}
-
-			state := getServiceState(flag.Args()[2])
-			enabled := strconv.FormatBool(isServiceEnabled(flag.Args()[2]))
-			enabled = strings.ToUpper(enabled[:1]) + strings.ToLower(enabled[1:])
-
-			fmt.Println("Service name: " + flag.Args()[2])
-			fmt.Printf("    State: %s\n", state)
-			fmt.Printf("    Enabled: %s\n", enabled)
-			return
-		}
-	}
-
-	printUsage()
-	os.Exit(1)
-}
-
-func getServiceState(serviceName string) string {
-	if _, err := os.Stat(path.Join(runstatedir, "esvm", serviceName)); err != nil {
-		return ""
-	}
-
-	var state uint64
-	bytes, err := os.ReadFile(path.Join(runstatedir, "esvm", serviceName, "state"))
-	if err != nil {
-		state = 0
-	}
-	state, err = strconv.ParseUint(string(bytes), 10, 8)
-
-	switch state {
-	case 1:
-		return "Unloaded"
-	case 2:
-		return "Running"
-	case 3:
-		return "Stopped"
-	case 4:
-		return "Crashed"
-	case 5:
-		return "Completed"
-	default:
-		return "Unknown"
-	}
-}
-
-func isServiceEnabled(serviceName string) bool {
-	if _, err := os.Stat(path.Join(sysconfdir, "esvm/enabled_services")); err != nil {
-		return false
-	}
-
-	file, err := os.ReadFile(path.Join(sysconfdir, "esvm/enabled_services"))
-	if err != nil {
-		return false
-	}
-
-	for _, line := range strings.Split(string(file), "\n") {
-		if strings.TrimSpace(line) == serviceName {
-			return true
-		}
-	}
-
-	return false
-}
-
-func printUsage() {
-	fmt.Println("Available sucommands:")
-	fmt.Println("ectl version | Show enit version")
-	fmt.Println("ectl shutdown/poweroff/halt | Shutdown the system")
-	fmt.Println("ectl reboot/restart | Reboot the system")
-	fmt.Println("ectl help | Show command explanations")
-	fmt.Println("ectl sv/service start <service> | Start a service")
-	fmt.Println("ectl sv/service stop <service> | Stop a service")
-	fmt.Println("ectl sv/service enable <service> | Enable a service at startup")
-	fmt.Println("ectl sv/service disable <service> | Disable a service at startup")
-	fmt.Println("ectl sv/service status <service> | Show service status")
-	fmt.Println("ectl sv/service list | Show all enabled services")
-}
-
-func dialSocket() {
-	if _, err := os.Stat(path.Join(runstatedir, "esvm/esvm.sock")); err != nil {
-		log.Fatalf("Could not find esvm.sock! Error: %s\n", err)
-	}
-
-	var err error
-	socket, err = net.Dial("unix", path.Join(runstatedir, "esvm/esvm.sock"))
-	if err != nil {
-		log.Fatalf("Failed to connect to esvm.sock! Error: %s\n", err)
-	}
-
-	if err := socket.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
-		log.Fatalf("Failed to set write deadline! Error: %s\n", err)
-	}
-}

cmd/esvm/go.sum

@@ -1,4 +0,0 @@
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

cmd/esvm/main.go

@@ -1,644 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"gopkg.in/yaml.v3"
-	"io"
-	"log"
-	"net"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path"
-	"slices"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-)
-
-type EnitServiceState uint8
-
-const (
-	EnitServiceUnknown EnitServiceState = iota
-	EnitServiceUnloaded
-	EnitServiceRunning
-	EnitServiceStopped
-	EnitServiceCrashed
-	EnitServiceCompleted
-)
-
-type EnitService struct {
-	Name            string   `yaml:"name"`
-	Description     string   `yaml:"description,omitempty"`
-	Dependencies    []string `yaml:"dependencies,omitempty"`
-	Type            string   `yaml:"type"`
-	StartCmd        string   `yaml:"start_cmd"`
-	ExitMethod      string   `yaml:"exit_method"`
-	CrashOnSafeExit bool     `yaml:"crash_on_safe_exit"`
-	StopCmd         string   `yaml:"stop_cmd,omitempty"`
-	Restart         string   `yaml:"restart,omitempty"`
-	LogOutput       bool     `yaml:"log_output,omitempty"`
-	ServiceRunPath  string
-	restartCount    int
-	stopChannel     chan bool
-}
-
-// Build-time variables
-var version = "dev"
-
-var runtimeServiceDir string
-var serviceConfigDir string
-
-var Services = make([]EnitService, 0)
-var EnabledServices = make([]string, 0)
-
-var logger *log.Logger
-var socket net.Listener
-
-func main() {
-	// Setup main logger
-	err := setupESVMLogger()
-	if err != nil {
-		log.Printf("Could not setup main ESVM logger! Error: %s\n", err)
-		logger = log.Default()
-	}
-
-	// Parse flags
-	printVersion := flag.Bool("version", false, "print version and exit")
-	flag.Parse()
-
-	if *printVersion || flag.NArg() != 2 {
-		fmt.Printf("Enit Service Manager version %s\n", version)
-		os.Exit(0)
-	}
-
-	if os.Getppid() != 1 {
-		fmt.Println("Esvm must be run by PID 1!")
-		os.Exit(1)
-	}
-
-	// Set directory variables
-	runtimeServiceDir = flag.Arg(0)
-	serviceConfigDir = flag.Arg(1)
-
-	Init()
-	if err != nil {
-
-	}
-
-	sigc := make(chan os.Signal, 1)
-	signal.Notify(sigc, syscall.SIGINT, syscall.SIGTERM)
-	go func() {
-		<-sigc
-		Destroy()
-		os.Exit(0)
-	}()
-
-	for {
-		listenToSocket()
-	}
-}
-
-func setupESVMLogger() error {
-	err := os.MkdirAll("/var/log/esvm", 0755)
-	if err != nil {
-		return err
-	}
-	loggerFile, err := os.OpenFile("/var/log/esvm/esvm.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
-	if err != nil {
-		return err
-	}
-	logger = log.New(loggerFile, "[ESVM] ", log.Lshortfile|log.LstdFlags)
-	// Print an empty line as separator
-	_, err = loggerFile.WriteString("------ " + time.Now().Format(time.UnixDate) + " ------\n")
-
-	return nil
-}
-
-func Init() {
-	logger.Println("Initializing ESVM...")
-
-	if _, err := os.Stat(runtimeServiceDir); err == nil {
-		logger.Fatalf("Could not initialize ESVM! Error: %s", fmt.Errorf("runtime service directory %s already exists", runtimeServiceDir))
-	}
-
-	err := os.MkdirAll(runtimeServiceDir, 0755)
-	if err != nil {
-		logger.Fatalf("Could not initialize ESVM! Error: %s", err)
-	}
-
-	socket, err = net.Listen("unix", path.Join(runtimeServiceDir, "esvm.sock"))
-	if err != nil {
-		logger.Fatalf("Could not initialize ESVM! Error: %s", err)
-	}
-
-	if stat, err := os.Stat(serviceConfigDir); err != nil || !stat.IsDir() {
-		logger.Println("ESVM initialized successfully!")
-		return
-	}
-
-	dirEntries, err := os.ReadDir(path.Join(serviceConfigDir, "services"))
-	if err != nil {
-		logger.Fatalf("Could not initialize ESVM! Error: %s", err)
-	}
-
-	// Read and initialize service files
-	for _, entry := range dirEntries {
-		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".esv") {
-			logger.Printf("Initializing service (%s)...\n", entry.Name())
-			bytes, err := os.ReadFile(path.Join(serviceConfigDir, "services", entry.Name()))
-			if err != nil {
-				logger.Printf("Could not read service file at %s!\n", path.Join(serviceConfigDir, "services", entry.Name()))
-				continue
-			}
-
-			service := EnitService{
-				Name:            "",
-				Description:     "",
-				Dependencies:    make([]string, 0),
-				Type:            "",
-				StartCmd:        "",
-				ExitMethod:      "",
-				StopCmd:         "",
-				Restart:         "",
-				CrashOnSafeExit: true,
-				ServiceRunPath:  "",
-				restartCount:    0,
-				stopChannel:     make(chan bool),
-				LogOutput:       true,
-			}
-			if err := yaml.Unmarshal(bytes, &service); err != nil {
-				logger.Printf("Could not read service file at %s!\n", path.Join(serviceConfigDir, "services", entry.Name()))
-				continue
-			}
-
-			for _, sv := range Services {
-				if sv.Name == service.Name {
-					logger.Printf("Service with name (%s) has already been initialized!", service.Name)
-				}
-			}
-
-			switch service.Type {
-			case "simple", "background":
-			default:
-				logger.Printf("Unknown service type: %s\n", service.Type)
-				continue
-			}
-
-			switch service.ExitMethod {
-			case "stop_command", "kill":
-			default:
-				logger.Printf("Unknown exit method: %s\n", service.ExitMethod)
-				continue
-			}
-
-			switch service.Restart {
-			case "true", "always":
-			default:
-				service.Restart = "false"
-			}
-
-			service.ServiceRunPath = path.Join(runtimeServiceDir, service.Name)
-			err = os.MkdirAll(path.Join(service.ServiceRunPath), 0755)
-			if err != nil {
-				logger.Fatalf("Could not initialize ESVM! Error: %s", err)
-			}
-
-			err = service.setCurrentState(EnitServiceUnloaded)
-			if err != nil {
-				logger.Fatalf("Could not initialize ESVM! Error: %s", err)
-			}
-
-			Services = append(Services, service)
-
-			logger.Printf("Service (%s) has been initialized!\n", service.Name)
-		}
-	}
-
-	// Get enabled services
-	if _, err := os.Stat(path.Join(serviceConfigDir, "enabled_services")); err == nil {
-		file, err := os.ReadFile(path.Join(serviceConfigDir, "enabled_services"))
-		if err != nil {
-			return
-		}
-		for _, line := range strings.Split(string(file), "\n") {
-			if line != "" {
-				EnabledServices = append(EnabledServices, line)
-			}
-		}
-	}
-
-	// Get enabled services that meet their dependencies
-	servicesWithMetDepends := make([]EnitService, 0)
-	for _, service := range Services {
-		if slices.Contains(EnabledServices, service.Name) && len(service.GetUnmetDependencies()) == 0 {
-			servicesWithMetDepends = append(servicesWithMetDepends, service)
-		}
-	}
-
-	// Loop until all enabled services have started or timed out
-	for start := time.Now(); time.Since(start) < 60*time.Second; {
-		if len(servicesWithMetDepends) == 0 {
-			break
-		}
-
-		for i := len(servicesWithMetDepends) - 1; i >= 0; i-- {
-			service := servicesWithMetDepends[i]
-			canStart := true
-			for _, dependency := range service.Dependencies {
-				if strings.HasPrefix(dependency, "/") {
-					// File dependency
-					if _, err := os.Stat(dependency); err != nil {
-						canStart = false
-						break
-					}
-				} else {
-					// Service dependency
-					if GetServiceByName(dependency).GetCurrentState() != EnitServiceRunning && GetServiceByName(dependency).GetCurrentState() != EnitServiceCompleted {
-						canStart = false
-						break
-					}
-				}
-			}
-			if canStart {
-				err := service.StartService()
-				if err != nil {
-					logger.Printf("Could not start service (%s)! Error: %s", service.Name, err)
-				}
-				servicesWithMetDepends = append(servicesWithMetDepends[:i], servicesWithMetDepends[i+1:]...)
-			}
-		}
-	}
-
-	if len(servicesWithMetDepends) > 0 {
-		for _, service := range servicesWithMetDepends {
-			logger.Printf("Could not start service (%s)! Error: dependencies not met", service.Name)
-		}
-	}
-
-	logger.Println("ESVM initialized successfully!")
-}
-
-func Destroy() {
-	logger.Println("Stopping all ESVM services...")
-	for _, service := range Services {
-		if err := service.StopService(); err != nil {
-			logger.Printf("Error stopping service %s! Error: %s\n", service.Name, err)
-		}
-	}
-	logger.Println("All ESVM services have stopped!")
-}
-
-func GetServiceByName(name string) *EnitService {
-	for _, service := range Services {
-		if service.Name == name {
-			return &service
-		}
-	}
-	return nil
-}
-
-func (service *EnitService) GetUnmetDependencies() (missingDependencies []string) {
-	for _, dependency := range service.Dependencies {
-		if strings.HasPrefix(dependency, "/") {
-			// File dependency
-			if _, err := os.Stat(dependency); err != nil {
-				missingDependencies = append(missingDependencies, dependency)
-			}
-		} else {
-			// Service dependency
-			depService := GetServiceByName(dependency)
-			if depService == nil {
-				missingDependencies = append(missingDependencies, dependency)
-			}
-		}
-	}
-
-	return missingDependencies
-}
-
-func (service *EnitService) GetProcess() *os.Process {
-	bytes, err := os.ReadFile(path.Join(service.ServiceRunPath, "process"))
-	if err != nil {
-		return nil
-	}
-
-	pid, err := strconv.Atoi(strings.TrimSpace(string(bytes)))
-	if err != nil {
-		return nil
-	}
-
-	process, err := os.FindProcess(pid)
-	if err != nil {
-		return nil
-	}
-
-	return process
-}
-
-func (service *EnitService) setProcessID(pid int) error {
-	if err := os.WriteFile(path.Join(service.ServiceRunPath, "process"), []byte(strconv.Itoa(pid)), 0644); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (service *EnitService) GetCurrentState() EnitServiceState {
-	bytes, err := os.ReadFile(path.Join(service.ServiceRunPath, "state"))
-	if err != nil {
-		return EnitServiceUnknown
-	}
-
-	state, err := strconv.Atoi(strings.TrimSpace(string(bytes)))
-	if err != nil {
-		return EnitServiceUnknown
-	}
-	return EnitServiceState(state)
-}
-
-func (service *EnitService) setCurrentState(state EnitServiceState) error {
-	if err := os.WriteFile(path.Join(service.ServiceRunPath, "state"), []byte(strconv.Itoa(int(state))), 0644); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (service *EnitService) GetLogFile() (file *os.File, err error) {
-	err = os.MkdirAll(path.Join("/var/log/esvm/"), 0755)
-	if err != nil {
-		return nil, err
-	}
-
-	file, err = os.OpenFile(path.Join("/var/log/esvm/", service.Name+".log"), os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = file.WriteString("------ " + time.Now().Format(time.UnixDate) + " ------\n")
-	if err != nil {
-		file.Close()
-		return nil, err
-	}
-
-	return file, nil
-}
-
-func (service *EnitService) StartService() error {
-	if service == nil {
-		return nil
-	}
-	if service.GetCurrentState() == EnitServiceRunning {
-		return nil
-	}
-
-	logger.Printf("Starting service (%s)...\n", service.Name)
-
-	// Get log file if service logs output
-	var logFile *os.File
-	if service.LogOutput {
-		var err error
-		logFile, err = service.GetLogFile()
-		if err != nil {
-			return err
-		}
-	}
-
-	cmd := exec.Command("/bin/sh", "-c", "exec "+service.StartCmd)
-	if logFile != nil {
-		cmd.Stdout = logFile
-		cmd.Stderr = logFile
-	}
-	if err := cmd.Start(); err != nil {
-		// Close log file if not nil
-		if logFile != nil {
-			logFile.Close()
-		}
-
-		return err
-	}
-
-	err := service.setProcessID(cmd.Process.Pid)
-	if err != nil {
-		// Close log file if not nil
-		if logFile != nil {
-			logFile.Close()
-		}
-
-		return err
-	}
-
-	err = service.setCurrentState(EnitServiceRunning)
-	if err != nil {
-		// Close log file if not nil
-		if logFile != nil {
-			logFile.Close()
-		}
-
-		return err
-	}
-
-	go func() {
-		err := cmd.Wait()
-
-		// Close log file if not nil
-		if logFile != nil {
-			logFile.Close()
-		}
-
-		select {
-		case <-service.stopChannel:
-			service.restartCount = 0
-			_ = service.setCurrentState(EnitServiceStopped)
-		default:
-			if service.Type == "simple" && err == nil {
-				service.restartCount = 0
-				_ = service.setCurrentState(EnitServiceCompleted)
-				return
-			}
-			if !service.CrashOnSafeExit {
-				logger.Printf("Service (%s) has exited\n", service.Name)
-				_ = service.setCurrentState(EnitServiceStopped)
-			} else {
-				logger.Printf("Service (%s) has crashed!\n", service.Name)
-				_ = service.setCurrentState(EnitServiceCrashed)
-			}
-
-			if service.Restart == "always" {
-				_ = service.StartService()
-			} else if service.Restart == "true" && service.restartCount < 5 {
-				service.restartCount++
-				_ = service.StartService()
-			}
-		}
-	}()
-
-	logger.Printf("Service (%s) has started!\n", service.Name)
-
-	return nil
-}
-
-func (service *EnitService) StopService() error {
-	if service.GetCurrentState() != EnitServiceRunning {
-		return nil
-	}
-
-	logger.Printf("Stopping service (%s)...\n", service.Name)
-
-	if service.ExitMethod == "kill" {
-		process := service.GetProcess()
-		if err := process.Signal(syscall.Signal(0)); err != nil {
-			logger.Printf("Service (%s) has stopped. (Process already dead)\n", service.Name)
-			return nil
-		}
-
-		go func() { service.stopChannel <- true }()
-
-		err := service.GetProcess().Signal(syscall.SIGTERM)
-		if err != nil {
-			return err
-		}
-
-		exit := false
-		for timeout := time.After(5 * time.Second); ; {
-			if exit {
-				break
-			}
-			select {
-			case <-timeout:
-				logger.Println("Process took too long to finish. Forcefully killing process...")
-				err := service.GetProcess().Kill()
-				if err != nil {
-					return err
-				}
-				exit = true
-			default:
-				if process == nil {
-					exit = true
-					break
-				}
-				err = process.Signal(syscall.Signal(0))
-				if err != nil {
-					exit = true
-				}
-			}
-		}
-	} else {
-		cmd := exec.Command("/bin/sh", "-c", service.StopCmd)
-		if err := cmd.Run(); err != nil {
-			return err
-		}
-	}
-
-	err := service.setCurrentState(EnitServiceStopped)
-	if err != nil {
-		return err
-	}
-
-	err = service.setProcessID(0)
-	if err != nil {
-		return err
-	}
-
-	logger.Printf("Service (%s) has stopped!\n", service.Name)
-
-	return nil
-}
-
-func (service *EnitService) RestartService() error {
-	if err := service.StopService(); err != nil {
-		return err
-	}
-
-	if err := service.StartService(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func listenToSocket() {
-	conn, err := socket.Accept()
-	if err != nil {
-		logger.Println("Could not accept socket connection!")
-		panic(err)
-	}
-
-	// Handle the connection in a separate goroutine.
-	go func(conn net.Conn) {
-		defer conn.Close()
-		// Create a buffer for incoming data.
-		buf := make([]byte, 4096)
-
-		// Read data from the connection.
-		n, err := conn.Read(buf)
-		if err == io.EOF {
-			return
-		}
-		if err != nil {
-			logger.Fatal(err)
-		}
-
-		command := string(buf[:n])
-		commandSplit := strings.Split(command, " ")
-
-		if len(commandSplit) >= 2 {
-			if commandSplit[0] == "start" {
-				service := GetServiceByName(commandSplit[1])
-				if service == nil {
-					_, err := conn.Write([]byte("service not found"))
-					if err != nil {
-						return
-					}
-				}
-				if err := service.StartService(); err != nil {
-					_, err := conn.Write([]byte("could not start service"))
-					if err != nil {
-						return
-					}
-				}
-				_, err := conn.Write([]byte("ok"))
-				if err != nil {
-					return
-				}
-			} else if commandSplit[0] == "stop" {
-				service := GetServiceByName(commandSplit[1])
-				if service == nil {
-					_, err := conn.Write([]byte("service not found"))
-					if err != nil {
-						return
-					}
-				}
-				if err := service.StopService(); err != nil {
-					_, err := conn.Write([]byte("could not stop service"))
-					if err != nil {
-						return
-					}
-				}
-				_, err := conn.Write([]byte("ok"))
-				if err != nil {
-					return
-				}
-			} else if commandSplit[0] == "restart" {
-				service := GetServiceByName(commandSplit[1])
-				if service == nil {
-					_, err := conn.Write([]byte("service not found"))
-					if err != nil {
-						return
-					}
-				}
-				if err := service.RestartService(); err != nil {
-					_, err := conn.Write([]byte("could not restart service"))
-					if err != nil {
-						return
-					}
-				}
-				_, err := conn.Write([]byte("ok"))
-				if err != nil {
-					return
-				}
-			}
-		}
-	}(conn)
-}

src/ectl/go.mod

@@ -0,0 +1,3 @@
+module ectl
+
+go 1.23.4

src/ectl/main.go

@@ -0,0 +1,376 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"os"
+	"path"
+	"strconv"
+	"syscall"
+	"time"
+)
+
+// Build-time variables
+var version = "dev"
+var sysconfdir = "/etc/"
+var runstatedir = "/var/run/"
+
+var conn net.Conn
+
+func main() {
+
+	// Set and parse flags
+	printVersion := flag.Bool("version", false, "print version and exit")
+	printJson := flag.Bool("json", false, "print output in json format")
+	flag.Parse()
+
+	// Dial esvm socket
+	dialSocket()
+	defer conn.Close()
+
+	if flag.NArg() < 1 {
+		printUsage()
+		os.Exit(1)
+	}
+
+	if *printVersion || flag.Args()[0] == "version" {
+		fmt.Printf("Enit Control version %s\n", version)
+		return
+	} else if flag.Args()[0] == "help" {
+		printUsage()
+		return
+	} else if flag.Args()[0] == "shutdown" || flag.Args()[0] == "poweroff" || flag.Args()[0] == "halt" {
+		err := syscall.Kill(1, syscall.SIGUSR1)
+		if err != nil {
+			log.Fatalf("Could not send shutdown signal! Error: %s\n", err)
+		}
+		return
+	} else if flag.Args()[0] == "reboot" || flag.Args()[0] == "restart" || flag.Args()[0] == "reset" {
+		err := syscall.Kill(1, syscall.SIGTERM)
+		if err != nil {
+			log.Fatalf("Could not send shutdown signal! Error: %s\n", err)
+		}
+		return
+	} else if flag.Args()[0] == "service" || flag.Args()[0] == "sv" {
+		if len(flag.Args()) <= 1 {
+			fmt.Println("Usage: ectl service <start/stop/enable/disable/status/list> [service]")
+			return
+		} else if flag.Arg(1) == "start" || flag.Arg(1) == "stop" || flag.Arg(1) == "restart" {
+			// Ensure service name argument has been set
+			if len(flag.Args()) <= 2 {
+				fmt.Printf("Usage: ectl service %s <service>\n", flag.Args()[1])
+				return
+			}
+
+			type ServiceCommandJsonStruct struct {
+				Command string `json:"command"`
+				Service string `json:"service"`
+			}
+			serviceCommandJson := ServiceCommandJsonStruct{
+				Command: flag.Arg(1),
+				Service: flag.Arg(2),
+			}
+
+			// Encode struct to json string
+			jsonData, err := json.Marshal(serviceCommandJson)
+			if err != nil {
+				log.Fatalf("Could not encode JSON data! Error: %s\n", err)
+			}
+
+			_, err = conn.Write(jsonData)
+			if err != nil {
+				log.Fatalf("Could not write JSON data to socket! Error: %s\n", err)
+			}
+
+			// Create a buffer for incoming data.
+			buf := make([]byte, 4096)
+
+			// Read data from the connection.
+			n, err := conn.Read(buf)
+			if err == io.EOF {
+				return
+			}
+			if err != nil {
+				return
+			}
+
+			// Print json data if flag is set
+			if *printJson {
+				fmt.Println(string(buf[:n]))
+				return
+			}
+
+			// Decoode JSON data
+			var returnedJsonData map[string]any
+			err = json.Unmarshal(buf[:n], &returnedJsonData)
+			if err != nil {
+				log.Fatalf("Could not decode JSON data from connection!")
+			}
+
+			if err, ok := returnedJsonData["error"]; ok {
+				log.Fatal(err)
+			} else if msg, ok := returnedJsonData["success"]; ok {
+				fmt.Println(msg)
+			} else {
+				log.Fatal("Connection returned empty string!")
+			}
+
+			return
+		} else if flag.Arg(1) == "enable" || flag.Arg(1) == "disable" {
+			// Ensure service name argument has been set
+			if len(flag.Args()) <= 2 {
+				fmt.Printf("Usage: ectl service %s <service> [stage]\n", flag.Args()[1])
+				return
+			}
+
+			// Get service stage
+			stage := 3
+			if len(flag.Args()) > 3 {
+				flagStr := flag.Arg(3)
+				_stage, err := strconv.ParseInt(flagStr, 10, 32)
+				if err != nil {
+					log.Fatalf("Error: could not parse stage number: %s", err)
+				}
+				stage = int(_stage)
+			} else if flag.Arg(1) == "disable" {
+				stage = 0
+			}
+
+			type ServiceCommandJsonStruct struct {
+				Command string `json:"command"`
+				Service string `json:"service"`
+				Stage   int    `json:"stage"`
+			}
+			serviceCommandJson := ServiceCommandJsonStruct{
+				Command: "set_enabled",
+				Service: flag.Arg(2),
+				Stage:   stage,
+			}
+
+			// Encode struct to json string
+			jsonData, err := json.Marshal(serviceCommandJson)
+			if err != nil {
+				log.Fatalf("Could not encode JSON data! Error: %s\n", err)
+			}
+
+			_, err = conn.Write(jsonData)
+			if err != nil {
+				log.Fatalf("Could not write JSON data to socket! Error: %s\n", err)
+			}
+
+			// Create a buffer for incoming data.
+			buf := make([]byte, 4096)
+
+			// Read data from the connection.
+			n, err := conn.Read(buf)
+			if err == io.EOF {
+				return
+			}
+			if err != nil {
+				return
+			}
+
+			// Print json data if flag is set
+			if *printJson {
+				fmt.Println(string(buf[:n]))
+				return
+			}
+
+			// Decoode JSON data
+			var returnedJsonData map[string]any
+			err = json.Unmarshal(buf[:n], &returnedJsonData)
+			if err != nil {
+				log.Fatalf("Could not decode JSON data from connection!")
+			}
+
+			if err, ok := returnedJsonData["error"]; ok {
+				log.Fatal(err)
+			} else if msg, ok := returnedJsonData["success"]; ok {
+				fmt.Println(msg)
+			} else {
+				log.Fatal("Connection returned empty string!")
+			}
+
+			return
+		} else if flag.Args()[1] == "status" {
+			// Ensure service name argument has been set
+			if len(flag.Args()) <= 2 {
+				fmt.Printf("Usage: ectl service %s <service>\n", flag.Args()[1])
+				return
+			}
+
+			type ServiceCommandJsonStruct struct {
+				Command string `json:"command"`
+				Service string `json:"service"`
+			}
+			serviceCommandJson := ServiceCommandJsonStruct{
+				Command: flag.Arg(1),
+				Service: flag.Arg(2),
+			}
+
+			// Encode struct to json string
+			jsonData, err := json.Marshal(serviceCommandJson)
+			if err != nil {
+				log.Fatalf("Could not encode JSON data! Error: %s\n", err)
+			}
+
+			_, err = conn.Write(jsonData)
+			if err != nil {
+				log.Fatalf("Could not write JSON data to socket! Error: %s\n", err)
+			}
+
+			// Create a buffer for incoming data.
+			buf := make([]byte, 4096)
+
+			// Read data from the connection.
+			n, err := conn.Read(buf)
+			if err == io.EOF {
+				return
+			}
+			if err != nil {
+				return
+			}
+
+			// Print json data if flag is set
+			if *printJson {
+				fmt.Println(string(buf[:n]))
+				return
+			}
+
+			// Decoode JSON data
+			var returnedJsonData map[string]any
+			err = json.Unmarshal(buf[:n], &returnedJsonData)
+			if err != nil {
+				log.Fatalf("Could not decode JSON data from connection!")
+			}
+
+			if err, ok := returnedJsonData["error"]; ok {
+				log.Fatal(err)
+			}
+
+			serviceState := returnedJsonData["state"].(string)
+			serviceEnabled := returnedJsonData["is_enabled"].(bool)
+			serviceStage := int(returnedJsonData["stage"].(float64))
+			processID := int(returnedJsonData["process_id"].(float64))
+
+			fmt.Printf("Name: %s\n", flag.Arg(2))
+			fmt.Printf("State: %s\n", serviceState)
+			if serviceEnabled {
+				fmt.Printf("Enabled: %t (Stage %d)\n", serviceEnabled, serviceStage)
+			} else {
+				fmt.Printf("Enabled: %t\n", serviceEnabled)
+			}
+			if serviceState == "running" {
+				fmt.Printf("Process ID: %d\n", processID)
+			}
+
+			return
+		} else if flag.Arg(1) == "list" {
+			type ServiceCommandJsonStruct struct {
+				Command string `json:"command"`
+			}
+			serviceCommandJson := ServiceCommandJsonStruct{
+				Command: flag.Arg(1),
+			}
+
+			// Encode struct to json string
+			jsonData, err := json.Marshal(serviceCommandJson)
+			if err != nil {
+				log.Fatalf("Could not encode JSON data! Error: %s\n", err)
+			}
+
+			_, err = conn.Write(jsonData)
+			if err != nil {
+				log.Fatalf("Could not write JSON data to socket! Error: %s\n", err)
+			}
+
+			// Create a buffer for incoming data.
+			buf := make([]byte, 4096)
+
+			// Read data from the connection.
+			n, err := conn.Read(buf)
+			if err == io.EOF {
+				return
+			}
+			if err != nil {
+				return
+			}
+
+			// Print json data if flag is set
+			if *printJson {
+				fmt.Println(string(buf[:n]))
+				return
+			}
+
+			// Decoode JSON data
+			var returnedJsonData map[string]any
+			err = json.Unmarshal(buf[:n], &returnedJsonData)
+			if err != nil {
+				log.Fatalf("Could not decode JSON data from connection!")
+			}
+
+			if err, ok := returnedJsonData["error"]; ok {
+				log.Fatal(err)
+			}
+
+			for _, serviceMap := range returnedJsonData["services"].([]any) {
+				serviceName := serviceMap.(map[string]any)["name"].(string)
+				serviceState := serviceMap.(map[string]any)["state"].(string)
+				serviceEnabled := serviceMap.(map[string]any)["is_enabled"].(bool)
+				serviceStage := int(serviceMap.(map[string]any)["stage"].(float64))
+				processID := int(serviceMap.(map[string]any)["process_id"].(float64))
+
+				fmt.Printf("Name: %s\n", serviceName)
+				fmt.Printf("State: %s\n", serviceState)
+				if serviceEnabled {
+					fmt.Printf("Enabled: %t (Stage %d)\n", serviceEnabled, serviceStage)
+				} else {
+					fmt.Printf("Enabled: %t\n", serviceEnabled)
+				}
+				if serviceState == "running" {
+					fmt.Printf("Process ID: %d\n", processID)
+				}
+				fmt.Println()
+			}
+
+			return
+		}
+	}
+
+	printUsage()
+	os.Exit(1)
+}
+
+func printUsage() {
+	fmt.Println("Available sucommands:")
+	fmt.Println("ectl version | Show enit version")
+	fmt.Println("ectl shutdown/poweroff/halt | Shutdown the system")
+	fmt.Println("ectl reboot/restart | Reboot the system")
+	fmt.Println("ectl help | Show command explanations")
+	fmt.Println("ectl sv/service start <service> | Start a service")
+	fmt.Println("ectl sv/service stop <service> | Stop a service")
+	fmt.Println("ectl sv/service enable <service> | Enable a service at startup")
+	fmt.Println("ectl sv/service disable <service> | Disable a service at startup")
+	fmt.Println("ectl sv/service status <service> | Show service status")
+	fmt.Println("ectl sv/service list | Show all enabled services")
+}
+
+func dialSocket() {
+	if _, err := os.Stat(path.Join(runstatedir, "esvm/esvm.sock")); err != nil {
+		log.Fatalf("Could not find esvm.sock! Error: %s\n", err)
+	}
+
+	var err error
+	conn, err = net.Dial("unix", path.Join(runstatedir, "esvm/esvm.sock"))
+	if err != nil {
+		log.Fatalf("Failed to connect to esvm.sock! Error: %s\n", err)
+	}
+
+	if err := conn.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
+		log.Fatalf("Failed to set write deadline! Error: %s\n", err)
+	}
+}

src/enit/main.go

@@ -149,40 +149,40 @@ func startServiceManager() {
 func stopServiceManager() {
 	fmt.Println("Stopping service manager... ")
 
-	err := syscall.Kill(serviceManagerPid, syscall.SIGTERM)
-	if err != nil {
+	process, _ := os.FindProcess(serviceManagerPid)
+
+	// Send SIGTERM signal to service manager
+	if err := process.Signal(syscall.SIGTERM); err != nil {
 		log.Println("Could not stop service manager!")
+		syscall.Kill(serviceManagerPid, syscall.SIGKILL)
+		return
 	}
 
 	// Check if service manager has stopped gracefully, otherwise send sigkill on timeout
-	exit := false
-	for timeout := time.After(60 * time.Second); ; {
-		if exit {
-			break
-		}
-		select {
-		case <-timeout:
-			log.Println("Could not stop service manager!")
-			err := syscall.Kill(serviceManagerPid, syscall.SIGKILL)
-			if err != nil {
-				log.Println("Could not stop service manager!")
-			}
-			exit = true
-		default:
-			waitZombieProcesses()
-			p, err := os.FindProcess(serviceManagerPid)
-			if err != nil {
-				exit = true
+	exited := make(chan bool)
+	go func() {
+		for {
+			if err := process.Signal(syscall.Signal(0)); err != nil {
 				break
 			}
-			err = p.Signal(syscall.Signal(0))
-			if err != nil {
-				exit = true
-			}
+		}
+		exited <- true
+	}()
+
+	for {
+		select {
+		case <-exited:
+			fmt.Println("Done.")
+			return
+		case <-time.After(60 * time.Second):
+			log.Println("Could not stop service manager!")
+			syscall.Kill(serviceManagerPid, syscall.SIGKILL)
+			return
+		default:
+			waitZombieProcesses()
 		}
 	}
 
-	fmt.Println("Done.")
 }
 
 func setHostname() {

src/enit/mount.go

@@ -2,11 +2,12 @@ package main
 
 import (
 	"fmt"
-	"golang.org/x/sys/unix"
 	"os"
 	"slices"
 	"strings"
 	"unsafe"
+
+	"golang.org/x/sys/unix"
 )
 
 var flagsEquivalence = map[string]uintptr{
@@ -104,7 +105,9 @@ func mount(source, target, fstype string, options string, mkdir bool) error {
 }
 
 func mountFstabEntries() error {
-	if _, err := os.Stat("/etc/fstab"); err != nil {
+	if _, err := os.Stat("/etc/fstab"); os.IsNotExist(err) {
+		return nil
+	} else if err != nil {
 		return err
 	}
 

src/esvm/main.go

@@ -0,0 +1,257 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"maps"
+	"net"
+	"os"
+	"os/signal"
+	"path"
+	"slices"
+	"strings"
+	"syscall"
+	"time"
+
+	"gopkg.in/yaml.v3"
+)
+
+// Build-time variables
+var version = "dev"
+
+var runtimeServiceDir string
+var serviceConfigDir string
+
+var logger *log.Logger
+var socket net.Listener
+
+func main() {
+	// Parse flags
+	printVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	if *printVersion || flag.NArg() != 2 {
+		fmt.Printf("Enit Service Manager version %s\n", version)
+		os.Exit(0)
+	}
+
+	if os.Getppid() != 1 {
+		fmt.Println("Esvm must be run by PID 1!")
+		os.Exit(1)
+	}
+
+	// Setup main logger
+	err := setupESVMLogger()
+	if err != nil {
+		log.Printf("Error: could not setup main ESVM logger: %s\n", err)
+		logger = log.Default()
+	}
+
+	// Set directory variables
+	runtimeServiceDir = flag.Arg(0)
+	serviceConfigDir = flag.Arg(1)
+
+	Init()
+	if err != nil {
+
+	}
+
+	sigc := make(chan os.Signal, 1)
+	signal.Notify(sigc, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-sigc
+		Destroy()
+		os.Exit(0)
+	}()
+
+	for {
+		listenToSocket()
+	}
+}
+
+func setupESVMLogger() error {
+	// Create esvm log directory
+	err := os.MkdirAll("/var/log/esvm", 0755)
+	if err != nil {
+		return err
+	}
+
+	// Create esvm old log directory
+	err = os.MkdirAll("/var/log/esvm/old", 0755)
+	if err != nil {
+		return err
+	}
+
+	// Move old log file
+	if _, err := os.Stat("/var/log/esvm/esvm.log"); err == nil {
+		os.Rename("/var/log/esvm/esvm.log", "/var/log/esvm/old/esvm.log")
+	}
+
+	// Open new log file
+	loggerFile, err := os.OpenFile("/var/log/esvm/esvm.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	if err != nil {
+		return err
+	}
+
+	// Setup multiwriter
+	w := io.MultiWriter(loggerFile, os.Stderr)
+
+	// Initialize logger and print a header line
+	logger = log.New(w, "[ESVM] ", log.Lshortfile|log.LstdFlags)
+	_, err = loggerFile.WriteString("------ " + time.Now().Format(time.UnixDate) + " ------\n")
+
+	return nil
+}
+
+func Init() {
+	logger.Println("Initializing ESVM...")
+
+	if _, err := os.Stat(runtimeServiceDir); err == nil {
+		logger.Fatalf("Error: could not initialize ESVM: %s", fmt.Errorf("runtime service directory %s already exists", runtimeServiceDir))
+	}
+
+	err := os.MkdirAll(runtimeServiceDir, 0755)
+	if err != nil {
+		logger.Fatalf("Error: could not initialize ESVM: %s", err)
+	}
+
+	socket, err = initSocket()
+	if err != nil {
+		logger.Fatalf("Error: could not initialize ESVM: %s", err)
+	}
+
+	if stat, err := os.Stat(serviceConfigDir); err != nil || !stat.IsDir() {
+		logger.Println("ESVM initialized successfully!")
+		return
+	}
+
+	dirEntries, err := os.ReadDir(path.Join(serviceConfigDir, "services"))
+	if err != nil {
+		logger.Fatalf("Error: Could not initialize ESVM: %s", err)
+	}
+
+	// Read and initialize service files
+	for _, entry := range dirEntries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".esv") {
+			logger.Printf("Initializing service (%s)...\n", entry.Name())
+			bytes, err := os.ReadFile(path.Join(serviceConfigDir, "services", entry.Name()))
+			if err != nil {
+				logger.Printf("Error: Could not read service file (%s)", path.Join(serviceConfigDir, "services", entry.Name()))
+				continue
+			}
+
+			service := EnitService{
+				Name:            "",
+				Description:     "",
+				Dependencies:    make([]string, 0),
+				Type:            "",
+				StartCmd:        "",
+				ExitMethod:      "",
+				StopCmd:         "",
+				Restart:         "",
+				CrashOnSafeExit: true,
+				restartCount:    0,
+				stopChannel:     make(chan bool),
+				LogOutput:       true,
+				state:           EnitServiceUnloaded,
+			}
+			if err := yaml.Unmarshal(bytes, &service); err != nil {
+				logger.Printf("Error: could not read service file %s", path.Join(serviceConfigDir, "services", entry.Name()))
+				continue
+			}
+
+			for _, sv := range Services {
+				if sv.Name == service.Name {
+					logger.Printf("Error: service with name (%s) has already been initialized", service.Name)
+				}
+			}
+
+			switch service.Type {
+			case "simple", "background":
+			default:
+				logger.Printf("Error: unknown service type (%s)", service.Type)
+				continue
+			}
+
+			switch service.ExitMethod {
+			case "stop_command", "kill":
+			default:
+				logger.Printf("Error: unknown exit method (%s)\n", service.ExitMethod)
+				continue
+			}
+
+			switch service.Restart {
+			case "true", "always":
+			default:
+				service.Restart = "false"
+			}
+
+			Services = append(Services, &service)
+
+			logger.Printf("Service (%s) has been initialized!\n", service.Name)
+		}
+	}
+
+	// Read enabled services
+	ReadEnabledServices()
+
+	// Start enabled services
+	stages := slices.Collect(maps.Keys(EnabledServices))
+	slices.Sort(stages)
+	for stage := 1; stage <= stages[len(stages)-1]; stage++ {
+		logger.Printf("Starting stage %d services...", stage)
+
+		services := EnabledServices[stage]
+		remainingServices := len(services)
+		for remainingServices != 0 {
+			for _, serviceName := range services {
+				service := GetServiceByName(serviceName)
+				if service == nil {
+					remainingServices--
+					continue
+				}
+
+				if len(service.GetUnmetDependencies()) == 0 {
+					err := service.StartService()
+					if err != nil {
+						logger.Printf("Error: could not start service (%s): %s", service.Name, err)
+					}
+					remainingServices--
+				}
+			}
+		}
+	}
+
+	logger.Println("ESVM initialized successfully!")
+}
+
+func Destroy() {
+	logger.Println("Stopping all ESVM services...")
+
+	// Loop through all started services in reverse
+	for i := len(startedServicesOrder) - 1; i >= 0; i-- {
+		// Get service by name
+		service := GetServiceByName(startedServicesOrder[i])
+		if service == nil {
+			continue
+		}
+
+		// Stop service
+		if err := service.StopService(); err != nil {
+			logger.Printf("Error: could not stop service (%s): %s", service.Name, err)
+		}
+	}
+
+	logger.Println("All ESVM services have stopped!")
+}
+
+func GetServiceByName(name string) *EnitService {
+	for _, service := range Services {
+		if service.Name == name {
+			return service
+		}
+	}
+	return nil
+}

src/esvm/service.go

@@ -0,0 +1,399 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path"
+	"slices"
+	"strings"
+	"syscall"
+	"time"
+
+	"gopkg.in/yaml.v3"
+)
+
+type EnitServiceState uint8
+
+const (
+	EnitServiceUnknown EnitServiceState = iota
+	EnitServiceUnloaded
+	EnitServiceStarting
+	EnitServiceRunning
+	EnitServiceStopped
+	EnitServiceCrashed
+	EnitServiceCompleted
+)
+
+var EnitServiceStateNames map[EnitServiceState]string = map[EnitServiceState]string{
+	EnitServiceUnknown:   "unknown",
+	EnitServiceUnloaded:  "unloaded",
+	EnitServiceStarting:  "starting",
+	EnitServiceRunning:   "running",
+	EnitServiceStopped:   "stopped",
+	EnitServiceCrashed:   "crashed",
+	EnitServiceCompleted: "completed",
+}
+
+type EnitService struct {
+	Name            string   `yaml:"name"`
+	Description     string   `yaml:"description,omitempty"`
+	Dependencies    []string `yaml:"dependencies,omitempty"`
+	Type            string   `yaml:"type"`
+	StartCmd        string   `yaml:"start_cmd"`
+	ExitMethod      string   `yaml:"exit_method"`
+	CrashOnSafeExit bool     `yaml:"crash_on_safe_exit"`
+	StopCmd         string   `yaml:"stop_cmd,omitempty"`
+	Restart         string   `yaml:"restart,omitempty"`
+	ReadyFd         int      `yaml:"ready_fd"`
+	LogOutput       bool     `yaml:"log_output,omitempty"`
+	state           EnitServiceState
+	processID       int
+	restartCount    int
+	stopChannel     chan bool
+}
+
+var Services = make([]*EnitService, 0)
+var EnabledServices = make(map[int][]string)
+var startedServicesOrder = make([]string, 0)
+
+func (service *EnitService) GetUnmetDependencies() (missingDependencies []string) {
+	for _, dependency := range service.Dependencies {
+		if strings.HasPrefix(dependency, "/") {
+			// File dependency
+			if _, err := os.Stat(dependency); err != nil {
+				missingDependencies = append(missingDependencies, dependency)
+			}
+		} else {
+			// Service dependency
+			depService := GetServiceByName(dependency)
+			if depService == nil {
+				missingDependencies = append(missingDependencies, dependency)
+			}
+		}
+	}
+
+	return missingDependencies
+}
+
+func (service *EnitService) GetProcess() *os.Process {
+	process, _ := os.FindProcess(service.processID)
+
+	return process
+}
+
+func (service *EnitService) GetLogFile() (file *os.File, err error) {
+	// Create esvm log directory
+	err = os.MkdirAll("/var/log/esvm", 0755)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create esvm old log directory
+	err = os.MkdirAll("/var/log/esvm/old", 0755)
+	if err != nil {
+		return nil, err
+	}
+
+	// Move old log file
+	if _, err := os.Stat(path.Join("/var/log/esvm/", service.Name+".log")); err == nil {
+		os.Rename(path.Join("/var/log/esvm/", service.Name+".log"), path.Join("/var/log/esvm/old", service.Name+".log"))
+	}
+
+	// Open new log file
+	file, err = os.OpenFile(path.Join("/var/log/esvm/", service.Name+".log"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	if err != nil {
+		return nil, err
+	}
+
+	// Initialize logger and print a header line
+	_, err = file.WriteString("------ " + time.Now().Format(time.UnixDate) + " ------\n")
+	if err != nil {
+		file.Close()
+		return nil, err
+	}
+
+	return file, nil
+}
+
+func (service *EnitService) StartService() (err error) {
+	if service == nil {
+		return nil
+	}
+	if service.state == EnitServiceRunning {
+		return nil
+	}
+
+	logger.Printf("Starting service (%s)...\n", service.Name)
+
+	// Get log file if service logs output
+	var logFile *os.File
+	if service.LogOutput {
+		logFile, err = service.GetLogFile()
+		if err != nil {
+			return err
+		}
+	}
+
+	cmd := exec.Command("/bin/sh", "-c", "exec "+service.StartCmd)
+	if logFile != nil {
+		cmd.Stdout = logFile
+		cmd.Stderr = logFile
+	}
+	var pipeReader, pipeWriter *os.File
+	if service.ReadyFd > 2 {
+		pipeReader, pipeWriter, err = os.Pipe()
+		if err != nil {
+			// Close log file if not nil
+			if logFile != nil {
+				logFile.Close()
+			}
+
+			return err
+		}
+
+		err := pipeReader.SetDeadline(time.Now().Add(10 * time.Second))
+		if err != nil {
+			// Close log file if not nil
+			if logFile != nil {
+				logFile.Close()
+			}
+
+			return err
+		}
+
+		for i := 3; i < service.ReadyFd; i++ {
+			cmd.ExtraFiles = append(cmd.ExtraFiles, nil)
+		}
+		cmd.ExtraFiles = append(cmd.ExtraFiles, pipeWriter)
+	}
+	if err := cmd.Start(); err != nil {
+		// Close log file if not nil
+		if logFile != nil {
+			logFile.Close()
+		}
+
+		return err
+	}
+
+	service.processID = cmd.Process.Pid
+	service.state = EnitServiceStarting
+
+	// Wait for data from pipe
+	if pipeReader != nil {
+		buffer := make([]byte, 1)
+		_, err := io.ReadAtLeast(pipeReader, buffer, 1)
+		if err != nil {
+			// Close log file if not nil
+			if logFile != nil {
+				logFile.Close()
+			}
+
+			// Kill process
+			cmd.Process.Kill()
+
+			service.processID = 0
+			service.state = EnitServiceCrashed
+
+			return err
+		}
+	}
+
+	service.state = EnitServiceRunning
+
+	go func() {
+		err := cmd.Wait()
+
+		// Close log file if not nil
+		if logFile != nil {
+			logFile.Close()
+		}
+
+		select {
+		case <-service.stopChannel:
+			service.restartCount = 0
+		default:
+			if service.Type == "simple" && err == nil {
+				service.restartCount = 0
+				if service.ExitMethod != "stop_command" {
+					service.state = EnitServiceCompleted
+				} else {
+					service.state = EnitServiceRunning
+				}
+				return
+			}
+			if !service.CrashOnSafeExit {
+				logger.Printf("Service (%s) has exited\n", service.Name)
+				service.state = EnitServiceStopped
+			} else {
+				logger.Printf("Service (%s) has crashed!\n", service.Name)
+				service.state = EnitServiceCrashed
+			}
+
+			if service.Restart == "always" {
+				_ = service.StartService()
+			} else if service.Restart == "true" && service.restartCount < 5 {
+				service.restartCount++
+				_ = service.StartService()
+			}
+		}
+
+		service.processID = 0
+	}()
+
+	// Add to started services order slice
+	if !slices.Contains(startedServicesOrder, service.Name) {
+		startedServicesOrder = append(startedServicesOrder, service.Name)
+	}
+
+	logger.Printf("Service (%s) has started!\n", service.Name)
+
+	return nil
+}
+
+func (service *EnitService) StopService() error {
+	if service.state != EnitServiceRunning {
+		return nil
+	}
+
+	logger.Printf("Stopping service (%s)...", service.Name)
+
+	newServiceStatus := EnitServiceCrashed
+	defer func() {
+		service.state = newServiceStatus
+		service.processID = 0
+	}()
+
+	if service.ExitMethod == "kill" {
+		if err := service.GetProcess().Signal(syscall.Signal(0)); err != nil {
+			newServiceStatus = EnitServiceStopped
+			logger.Printf("Service (%s) has stopped (Process already dead)", service.Name)
+			return nil
+		}
+
+		go func() { service.stopChannel <- true }()
+
+		// Send SIGTERM signal to process
+		if err := service.GetProcess().Signal(syscall.SIGTERM); err != nil {
+			service.GetProcess().Signal(syscall.SIGKILL)
+			return fmt.Errorf("could not stop process gracefully")
+		}
+
+		// Check if the process has stopped gracefully, otherwise send sigkill on timeout
+		exited := make(chan bool)
+		go func() {
+			for {
+				if err := service.GetProcess().Signal(syscall.Signal(0)); err != nil {
+					break
+				}
+			}
+			exited <- true
+		}()
+
+		select {
+		case <-exited:
+		case <-time.After(5 * time.Second):
+			service.GetProcess().Signal(syscall.SIGKILL)
+			return fmt.Errorf("could not stop process gracefully")
+		}
+	} else {
+		cmd := exec.Command("/bin/sh", "-c", service.StopCmd)
+		if err := cmd.Run(); err != nil {
+			return err
+		}
+	}
+
+	newServiceStatus = EnitServiceStopped
+	logger.Printf("Service (%s) has stopped!\n", service.Name)
+
+	return nil
+}
+
+func (service *EnitService) RestartService() error {
+	if err := service.StopService(); err != nil {
+		return err
+	}
+
+	if err := service.StartService(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Functions will be rewritten at some point to allow enabling unloaded services
+
+func (service *EnitService) isEnabled() (bool, int) {
+	for stage, services := range EnabledServices {
+		if slices.Contains(services, service.Name) {
+			return true, stage
+		}
+	}
+
+	return false, 0
+}
+
+func (service *EnitService) SetEnabled(stage int) error {
+	// Get current service enabled status
+	_, s := service.isEnabled()
+
+	// Return if service is already in correct state
+	if s == stage {
+		return nil
+	}
+
+	// Remove service from current stage
+	EnabledServices[s] = slices.DeleteFunc(EnabledServices[s], func(name string) bool {
+		return name == service.Name
+	})
+	if len(EnabledServices[s]) == 0 {
+		delete(EnabledServices, s)
+	}
+
+	// Add service to stage
+	if stage != 0 {
+		EnabledServices[stage] = append(EnabledServices[stage], service.Name)
+	}
+
+	// Save enabled services to file
+	data, err := yaml.Marshal(EnabledServices)
+	if err != nil {
+		return err
+	}
+	err = os.WriteFile(path.Join(serviceConfigDir, "enabled_services"), data, 0644)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func ReadEnabledServices() error {
+	data, err := os.ReadFile(path.Join(serviceConfigDir, "enabled_services"))
+	if err != nil {
+		return err
+	}
+
+	err = yaml.Unmarshal(data, &EnabledServices)
+	if err != nil {
+		// Assume old plain text format
+		for _, service := range strings.Split(strings.TrimSpace(string(data)), "\n") {
+			EnabledServices[3] = append(EnabledServices[3], service)
+		}
+
+		// Update enabled_services file
+		data, err := yaml.Marshal(EnabledServices)
+		if err != nil {
+			return err
+		}
+		err = os.WriteFile(path.Join(serviceConfigDir, "enabled_services"), data, 0644)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}
+
+	return nil
+}

src/esvm/socket.go

@@ -0,0 +1,295 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"path"
+)
+
+var commandHandlers = make(map[string]func(conn net.Conn, jsonData map[string]any))
+
+func initSocket() (socket net.Listener, err error) {
+	socket, err = net.Listen("unix", path.Join(runtimeServiceDir, "esvm.sock"))
+	if err != nil {
+		return nil, err
+	}
+
+	// Register command handlers
+	commandHandlers["start"] = handleStartServiceCommand
+	commandHandlers["stop"] = handleStopServiceCommand
+	commandHandlers["restart"] = handleRestartServiceCommand
+	commandHandlers["set_enabled"] = handleSetEnabledServiceCommand
+	commandHandlers["status"] = handleStatusServiceCommand
+	commandHandlers["list"] = handleListServicesCommand
+
+	return socket, nil
+}
+
+func listenToSocket() {
+	conn, err := socket.Accept()
+	if err != nil {
+		logger.Println("Could not accept socket connection!")
+		panic(err)
+	}
+
+	// Handle the connection in a separate goroutine.
+	go func(conn net.Conn) {
+		defer conn.Close()
+		// Create a buffer for incoming data.
+		buf := make([]byte, 4096)
+
+		// Read data from the connection.
+		n, err := conn.Read(buf)
+		if err == io.EOF {
+			return
+		}
+		if err != nil {
+			return
+		}
+
+		// Decoode JSON data
+		var jsonData map[string]any
+		err = json.Unmarshal(buf[:n], &jsonData)
+		if err != nil {
+			conn.Write(wrapErrorInJson(fmt.Errorf("Invalid JSON")))
+			return
+		}
+
+		// Get command to execute
+		command, ok := jsonData["command"]
+		if !ok {
+			conn.Write(wrapErrorInJson(fmt.Errorf("'command' field missing")))
+			return
+		}
+
+		// Get command handler
+		commandHandler, ok := commandHandlers[command.(string)]
+		if !ok {
+			conn.Write(wrapErrorInJson(fmt.Errorf("command (%s) has not been implemented", command.(string))))
+			return
+		}
+		commandHandler(conn, jsonData)
+	}(conn)
+}
+
+func handleStartServiceCommand(conn net.Conn, jsonData map[string]any) {
+	// Get service name from json data
+	serviceName, ok := jsonData["service"]
+	if !ok {
+		conn.Write(wrapErrorInJson(fmt.Errorf("'service' field missing")))
+		return
+	}
+
+	// Ensure service exists
+	service := GetServiceByName(serviceName.(string))
+	if service == nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Service (%s) not found", serviceName.(string))))
+		return
+	}
+
+	// Start the service
+	if err := service.StartService(); err != nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Service (%s) could not be started", serviceName.(string))))
+		return
+	}
+
+	conn.Write(wrapSuccessMsgInJson(fmt.Sprintf("Service (%s) has started sucessfully", serviceName.(string))))
+}
+
+func handleStopServiceCommand(conn net.Conn, jsonData map[string]any) {
+	// Get service name from json data
+	serviceName, ok := jsonData["service"]
+	if !ok {
+		conn.Write(wrapErrorInJson(fmt.Errorf("'service' field missing")))
+		return
+	}
+
+	// Ensure service exists
+	service := GetServiceByName(serviceName.(string))
+	if service == nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Service (%s) not found", serviceName.(string))))
+		return
+	}
+
+	// Stop the service
+	if err := service.StopService(); err != nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Service (%s) could not be stopped", serviceName.(string))))
+		return
+	}
+
+	conn.Write(wrapSuccessMsgInJson(fmt.Sprintf("Service (%s) has stopped sucessfully", serviceName.(string))))
+}
+
+func handleRestartServiceCommand(conn net.Conn, jsonData map[string]any) {
+	// Get service name from json data
+	serviceName, ok := jsonData["service"]
+	if !ok {
+		conn.Write(wrapErrorInJson(fmt.Errorf("'service' field missing")))
+		return
+	}
+
+	// Ensure service exists
+	service := GetServiceByName(serviceName.(string))
+	if service == nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Service (%s) not found", serviceName.(string))))
+		return
+	}
+
+	// Restart the service
+	if err := service.RestartService(); err != nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Service (%s) could not be restarted", serviceName.(string))))
+		return
+	}
+
+	conn.Write(wrapSuccessMsgInJson(fmt.Sprintf("Service (%s) has restarted sucessfully", serviceName.(string))))
+}
+
+func handleSetEnabledServiceCommand(conn net.Conn, jsonData map[string]any) {
+	// Get service name from json data
+	serviceName, ok := jsonData["service"]
+	if !ok {
+		conn.Write(wrapErrorInJson(fmt.Errorf("'service' field missing")))
+		return
+	}
+
+	// Get service stage from json json data
+	_serviceStage, ok := jsonData["stage"]
+	if !ok {
+		conn.Write(wrapErrorInJson(fmt.Errorf("'stage' field missing")))
+		return
+	}
+	serviceStage, ok := _serviceStage.(float64)
+	if !ok {
+		conn.Write(wrapErrorInJson(fmt.Errorf("'stage' field is not a number")))
+		return
+	}
+
+	// Ensure service exists
+	service := GetServiceByName(serviceName.(string))
+	if service == nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Service (%s) not found", serviceName.(string))))
+		return
+	}
+
+	// Get current service enabled status
+	_, s := service.isEnabled()
+
+	// Return if service is already in correct state
+	if s == int(serviceStage) {
+		if serviceStage == 0 {
+			conn.Write(wrapSuccessMsgInJson(fmt.Sprintf("Service (%s) is already disabled", serviceName.(string))))
+		} else {
+			conn.Write(wrapSuccessMsgInJson(fmt.Sprintf("Service (%s) is already enabled", serviceName.(string))))
+		}
+		return
+	}
+
+	// Enable service
+	err := service.SetEnabled(int(serviceStage))
+	if err != nil {
+		if serviceStage == 0 {
+			conn.Write(wrapErrorInJson(fmt.Errorf("Could not disable service! Error: %s", err)))
+		} else {
+			conn.Write(wrapErrorInJson(fmt.Errorf("Could not enable service! Error: %s", err)))
+		}
+		return
+	}
+
+	if serviceStage == 0 {
+		conn.Write(wrapSuccessMsgInJson(fmt.Sprintf("Service (%s) was disabled sucessfully", serviceName.(string))))
+	} else {
+		conn.Write(wrapSuccessMsgInJson(fmt.Sprintf("Service (%s) was enabled sucessfully", serviceName.(string))))
+	}
+
+}
+
+func handleStatusServiceCommand(conn net.Conn, jsonData map[string]any) {
+	// Get service name from json data
+	serviceName, ok := jsonData["service"]
+	if !ok {
+		conn.Write(wrapErrorInJson(fmt.Errorf("'service' field missing")))
+		return
+	}
+
+	// Ensure service exists
+	service := GetServiceByName(serviceName.(string))
+	if service == nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Service (%s) not found", serviceName.(string))))
+		return
+	}
+
+	statusMap := make(map[string]any)
+	statusMap["name"] = service.Name
+	statusMap["state"] = EnitServiceStateNames[service.state]
+	statusMap["process_id"] = service.processID
+	statusMap["is_enabled"], statusMap["stage"] = service.isEnabled()
+
+	// Encode map to json string
+	newJsonData, err := json.Marshal(statusMap)
+	if err != nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Could not encode JSON data")))
+		return
+	}
+
+	conn.Write(newJsonData)
+}
+
+func handleListServicesCommand(conn net.Conn, _ map[string]any) {
+	servicesMap := make(map[string]any)
+	servicesMap["services"] = make([]map[string]any, 0)
+
+	// Loop through each service
+	for _, service := range Services {
+		statusMap := make(map[string]any)
+		statusMap["name"] = service.Name
+		statusMap["state"] = EnitServiceStateNames[service.state]
+		statusMap["process_id"] = service.processID
+		statusMap["is_enabled"], statusMap["stage"] = service.isEnabled()
+		servicesMap["services"] = append(servicesMap["services"].([]map[string]any), statusMap)
+	}
+
+	// Encode map to json string
+	newJsonData, err := json.Marshal(servicesMap)
+	if err != nil {
+		conn.Write(wrapErrorInJson(fmt.Errorf("Could not encode JSON data")))
+		return
+	}
+
+	conn.Write(newJsonData)
+}
+
+func wrapErrorInJson(err error) []byte {
+	// Wrap error in struct
+	type jsonErrorStruct struct {
+		Error string `json:"error"`
+	}
+	jsonError := jsonErrorStruct{
+		Error: err.Error(),
+	}
+
+	// Encode struct to json string
+	jsonData, _err := json.Marshal(jsonError)
+	if _err != nil {
+		return nil
+	}
+	return jsonData
+}
+
+func wrapSuccessMsgInJson(msg string) []byte {
+	// Wrap message in struct
+	type jsonSuccessStruct struct {
+		Success string `json:"success"`
+	}
+	jsonSuccess := jsonSuccessStruct{
+		Success: msg,
+	}
+
+	// Encode struct to json string
+	jsonData, _err := json.Marshal(jsonSuccess)
+	if _err != nil {
+		return nil
+	}
+	return jsonData
+}