From 61a51130ddffba54aef0c2ce2ceafaf616944a2a Mon Sep 17 00:00:00 2001
From: Simon Martens <simon.martens@mailbox.org>
Date: Mon, 11 Nov 2024 17:22:01 +0100
Subject: [PATCH] BUGFIX: all interrupts & server restart work now

---
 kgpz_web.go      | 10 ++++-----
 server/server.go | 58 +++++++++++++++++++++++++++++-------------------
 2 files changed, 40 insertions(+), 28 deletions(-)

diff --git a/kgpz_web.go b/kgpz_web.go
index 2a94712..2dee142 100644
--- a/kgpz_web.go
+++ b/kgpz_web.go
@@ -46,7 +46,6 @@ func Start(k *app.KGPZ, s *server.Server) {
 
 	sigs := make(chan os.Signal, 1)
 	done := make(chan bool, 1)
-	serversignals := s.Events.Subscribe(1)
 
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 
@@ -54,10 +53,10 @@ func Start(k *app.KGPZ, s *server.Server) {
 		_ = <-sigs
 		fmt.Println("Received signal. Cleaning up.")
 		// INFO: here we add cleanup functions
-		s.Kill()
-		s.BreakUntil(serversignals, server.Killed)
-		fmt.Println("Server killed.")
+		s.Stop()
+		fmt.Println("Server stopped. Waiting for FS.")
 		k.Shutdown()
+		fmt.Println("FS stopped. Exiting.")
 		done <- true
 	}()
 
@@ -74,7 +73,8 @@ func Start(k *app.KGPZ, s *server.Server) {
 					fmt.Println("Pulling repo.")
 					k.Pull()
 				} else if input == "q" {
-					done <- true
+					s := os.Signal(syscall.SIGTERM)
+					sigs <- s
 				}
 			}
 		}()
diff --git a/server/server.go b/server/server.go
index d3c7e9c..d244bd5 100644
--- a/server/server.go
+++ b/server/server.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"sync"
 
 	"githib.com/Theodor-Springmann-Stiftung/kgpz_web/app"
 )
@@ -30,6 +31,8 @@ const (
 // - we reload all clients
 // - if data validity catastrophically fails, we restart the router to map error pages.
 type Server struct {
+	running  *sync.WaitGroup
+	shutdown *sync.WaitGroup
 }
 
 func Start(k *app.KGPZ) *Server {
@@ -38,17 +41,38 @@ func Start(k *app.KGPZ) *Server {
 
 func (s *Server) Start() {
 	srv := &http.Server{Addr: ":8081"}
-	s.killHandler(srv)
-	s.shutdownHandler(srv)
-	s.runnerHandler(srv)
-	s.restartHandler()
+	s.runner(srv)
 }
 
-func (s *Server) runnerHandler(srv *http.Server) {
+func (s *Server) Stop() {
+	if s.running == nil {
+		return
+	}
+
+	s.running.Done()
+	s.shutdown.Wait()
+}
+
+func (s *Server) Restart() {
+	if s.running != nil {
+		s.running.Done()
+		s.shutdown.Wait()
+	}
+	s.Start()
+}
+
+func (s *Server) runner(srv *http.Server) {
+	s.running = &sync.WaitGroup{}
+	s.shutdown = &sync.WaitGroup{}
+
+	s.running.Add(1)
+	s.shutdown.Add(1)
+
+	cleanup := sync.WaitGroup{}
+	cleanup.Add(1)
 
-	shutttingdown := s.Events.Subscribe(1)
 	go func() {
-		s.Events.Publish(Running)
+		defer s.shutdown.Done()
 		// EXAMPLE:
 		mux := http.NewServeMux()
 		mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
@@ -62,28 +86,16 @@ func (s *Server) runnerHandler(srv *http.Server) {
 			return
 		}
 
-	loop:
-		for {
-			msg := <-shutttingdown
-			if msg == ShuttingDown {
-				s.Events.Publish(ShuttedDown)
-				break loop
-			}
-			if msg == Killing {
-				s.Events.Publish(Killed)
-				break loop
-			}
-		}
+		cleanup.Wait()
 	}()
 
 	go func() {
-		s.BreakUntil(shutdown, ShutDown)
-		fmt.Println("Shutting down server")
+		defer cleanup.Done()
+		s.running.Wait()
+
 		if err := srv.Shutdown(nil); err != nil {
 			fmt.Println("Error shutting down server")
 		}
-
-		s.Events.Publish(ShuttingDown)
 	}()
 
 }