add first supervisor process

.gitea/workflows/build.yaml

@@ -30,6 +30,10 @@ jobs:
             ext: ""
 
     steps:
+      - name: Install zip
+        run: |
+          apt-get update && apt-get install -y zip
+
       - name: Checkout repo
         uses: actions/checkout@v4
 
@@ -44,7 +48,7 @@ jobs:
           if [ ! -x "$GOROOT/bin/go" ]; then
             echo "Go not found in $GOROOT, downloading latest stable..."
             
-            GO_VERSION=$(curl -s https://go.dev/VERSION?m=text)
+            GO_VERSION=$(curl -s https://go.dev/VERSION?m=text | head -n1)
             echo "Latest version is $GO_VERSION"
 
             mkdir -p /data/go
@@ -56,16 +60,6 @@ jobs:
 
           go version
 
-      - name: Cache Go build and module cache in /data
-        uses: actions/cache@v4
-        with:
-          path: |
-            /data/gocache
-            /data/gomodcache
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-
       - name: Download Go dependencies
         run: |
           export GOROOT=/data/go/go

dist/supervisorTemplate.json

@@ -0,0 +1,10 @@
+{
+"processes":[{
+    "name":"Database DBM",
+    "executePath":"dist/test-windows-amd64.exe",
+    "workingDirectory":".",
+    "startDelay":2,
+    "priority":0
+}
+]
+}

handlers/htopHandler.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"embed"
 	"encoding/json"
 	"html/template"
 	"net/http"
@@ -9,15 +10,17 @@ import (
 
 type HTopHandler struct {
 	Table     *models.HtopTable
+	templates *embed.FS
 }
 
-func NewHTopHandler() (*HTopHandler, error) {
+func NewHTopHandler(templates *embed.FS) (*HTopHandler, error) {
 	table, err := models.NewTable()
 	if err != nil {
 		return nil, err
 	}
 	return &HTopHandler{
 		Table:     table,
+		templates: templates,
 	}, nil
 }
 
@@ -38,14 +41,18 @@ func (h *HTopHandler) UpdateHTop(w http.ResponseWriter, r *http.Request) {
 	// Detect HTMX request via the HX-Request header
 	if r.Header.Get("HX-Request") == "true" {
 		tmpl := template.Must(
-			template.New("table.html").Funcs(funcMap).ParseFiles("templates/htop/table.html"),
+			template.New("table.html").Funcs(funcMap).ParseFS(
+				h.templates,
+				"templates/htop/table.html",
+			),
 		)
 		tmpl.Execute(w, h.Table)
 		return
 	}
 
 	tmpl := template.Must(
-		template.New("htop.html").Funcs(funcMap).ParseFiles(
+		template.New("htop.html").Funcs(funcMap).ParseFS(
+			h.templates,
 			"templates/htop/htop.html",
 			"templates/htop/table.html",
 		),

handlers/mainPage.go

@@ -1,17 +1,47 @@
 package handlers
 
 import (
+	"embed"
+	"fmt"
 	"html/template"
 	"net/http"
+	"os"
+	"processSupervisor/models"
 )
 
 type MainPage struct {
+	templates  *embed.FS
+	Supervisor *models.Supervisor
 }
 
-func UpdateMainPage(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+func NewMainPage(templates *embed.FS) (*MainPage, error) {
+	fmt.Println(10)
+	fmt.Println(os.Getwd())
+	var supervisor models.Supervisor
+	if _, err := os.Stat("cfg/"); err != nil {
+		s, err := models.ReadTemplate("dist/supervisorTemplate.json")
+		if err != nil {
+			return nil, err
+		}
+		supervisor = s
+	}
+	fmt.Println(11)
+
+	if err := supervisor.StartProcesses(); err != nil {
+		return nil, err
+	}
+	return &MainPage{
+		templates:  templates,
+		Supervisor: &supervisor,
+	}, nil
+}
+
+func (m *MainPage) UpdateMainPage(w http.ResponseWriter, r *http.Request) {
 	tmpl := template.Must(
-		template.New("index.html").ParseFiles("templates/index.html"),
+		template.New("index.html").ParseFS(
+			m.templates,
+			"templates/index.html",
+		),
 	)
 	tmpl.Execute(w, nil)
 }

main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"embed"
 	"flag"
 	"fmt"
 	"log"
@@ -8,24 +9,32 @@ import (
 	"processSupervisor/handlers"
 )
 
+//go:embed templates/*.html templates/*/*.html
+var templatesFS embed.FS
+
+//go:embed static
+var staticFS embed.FS
+
 func main() {
 
-	port := flag.Uint("port", 9400, "listenig port")
-	flag.Parse()
-
-	htop, err := handlers.NewHTopHandler()
+	port := flag.Uint("port", 9400, "listening port")
+	htop, err := handlers.NewHTopHandler(&templatesFS)
 	if err != nil {
 		panic(err)
 	}
 
-	fs := http.FileServer(http.Dir("static"))
-	http.Handle("/static/", http.StripPrefix("/static/", fs))
+	mianPage, err := handlers.NewMainPage(&templatesFS)
+	if err != nil {
+		panic(err)
+	}
+
+	http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))))
 
 	http.HandleFunc("/taskmanager/htop", htop.UpdateHTop)
-	http.HandleFunc("/", handlers.UpdateMainPage)
+	http.HandleFunc("/", mianPage.UpdateMainPage)
 	http.HandleFunc("/taskmanager/kill", handlers.KillHandler)
 	http.HandleFunc("/taskmanager/usage", handlers.UsageHandler)
 
-	log.Printf("Listening on http://localhost:%d/taskmanager/htop\n", *port)
+	log.Printf("Listening on http://localhost:%d\n", *port)
 	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *port), nil))
 }

models/supervisor.go

@@ -0,0 +1,57 @@
+package models
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"sort"
+)
+
+type Supervisor struct {
+	Processes []*SupervisorProcess `json:"processes"`
+}
+
+type SupervisorProcess struct {
+	Name             string    `json:"name"`
+	ExecutePath      string    `json:"executePath"`
+	WorkingDirectory string    `json:"workingDirectory,omitempty"`
+	StartDelay       int       `json:"startDelay,omitempty"`
+	Priority         int       `json:"priority,omitempty"`
+	Arguments        []string  `json:"arguments,omitempty"`
+	process          *exec.Cmd `json:"-"`
+}
+
+func ReadTemplate(path string) (supervisor Supervisor, err error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return
+	}
+
+	err = json.Unmarshal(content, &supervisor)
+	return
+}
+
+func (s *Supervisor) StartProcesses() error {
+	sort.Slice(s.Processes, func(i, j int) bool {
+		return s.Processes[i].Priority < s.Processes[j].Priority
+	})
+
+	for _, p := range s.Processes {
+		go func() {
+			p.process = exec.Command(p.ExecutePath, p.Arguments...)
+			//cmd.Env = append(cmd.Env, "MY_VAR=some_value")
+			p.process.Dir = p.WorkingDirectory
+
+			output, err := p.process.Output()
+			if err != nil {
+				fmt.Println("Error:", err)
+			}
+
+			fmt.Println("Output:", string(output))
+		}()
+	}
+	fmt.Println(3)
+
+	return nil
+}