Rework some things to prepare for the cleanup of old diagrams

internal/cleanup_service.go

@@ -0,0 +1,41 @@
+package internal
+
+import (
+	"log"
+	"time"
+)
+
+// NewCleanupService returns a service that can be used cleanup old diagrams.
+func NewCleanupService(generator Generator) *cleanupService {
+	return &cleanupService{
+		generator: generator,
+		stopCh:    make(chan struct{}),
+	}
+}
+
+// cleanupService is a service that can be used cleanup old diagrams.
+type cleanupService struct {
+	generator Generator
+	stopCh    chan struct{}
+}
+
+// Start starts the cleanup service.
+func (s *cleanupService) Start() error {
+	for {
+		if err := s.generator.CleanUp(time.Hour); err != nil {
+			log.Printf("error when cleaning up: %s", err.Error())
+		}
+
+		select {
+		case <-time.After(time.Minute * 5):
+			continue
+		case <-s.stopCh:
+			return nil
+		}
+	}
+}
+
+// Stop stops the cleanup service.
+func (s *cleanupService) Stop() {
+	close(s.stopCh)
+}

internal/generator.go

@@ -8,14 +8,18 @@ import (
 	"log"
 	"os"
 	"os/exec"
+	"time"
 )
 
 // Generator provides the ability to generate a diagram.
 type Generator interface {
 	// Generate generates the given diagram.
 	Generate(diagram *Diagram) error
+	// CleanUp removes any diagrams that haven't used within the given duration.
+	CleanUp(duration time.Duration) error
 }
 
+// NewGenerator returns a generator that can be used to generate diagrams.
 func NewGenerator(cache DiagramCache, mermaidCLIPath string, inPath string, outPath string, puppeteerConfigPath string) Generator {
 	return &cachingGenerator{
 		cache:               cache,
@@ -102,3 +106,9 @@ func (c cachingGenerator) generate(diagram *Diagram) error {
 
 	return nil
 }
+
+// CleanUp removes any diagrams that haven't used within the given duration.
+func (c cachingGenerator) CleanUp(duration time.Duration) error {
+	// todo : loop through all cached diagrams and delete any that haven't been used within duration.
+	return nil
+}

internal/http.go

@@ -80,8 +80,8 @@ func getDiagramFromPOST(rw http.ResponseWriter, r *http.Request) *Diagram {
 	return d
 }
 
-// GenerateHTTPHandler returns a HTTP handler used to generate a diagram.
-func GenerateHTTPHandler(generator Generator) func(rw http.ResponseWriter, r *http.Request) {
+// generateHTTPHandler returns a HTTP handler used to generate a diagram.
+func generateHTTPHandler(generator Generator) func(rw http.ResponseWriter, r *http.Request) {
 	return func(rw http.ResponseWriter, r *http.Request) {
 		var diagram *Diagram
 

internal/http_service.go

@@ -0,0 +1,47 @@
+package internal
+
+import (
+	"net/http"
+)
+
+// NewHTTPService returns a service that can be used to start a http server
+// that will generate diagrams.
+func NewHTTPService(generator Generator) *httpService {
+	return &httpService{
+		generator: generator,
+	}
+}
+
+// httpService is a service that can be used to start a http server
+// that will generate diagrams.
+type httpService struct {
+	httpServer *http.Server
+	generator  Generator
+}
+
+// Start starts the HTTP server.
+func (s *httpService) Start() error {
+	httpHandler := generateHTTPHandler(s.generator)
+
+	r := http.NewServeMux()
+	r.Handle("/generate", http.HandlerFunc(httpHandler))
+
+	s.httpServer = &http.Server{
+		Addr:    ":80",
+		Handler: r,
+	}
+
+	if err := s.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		if err != http.ErrServerClosed {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *httpService) Stop() {
+	if s != nil {
+		_ = s.httpServer.Close()
+	}
+}