Fixed display of site target

handlers/auth.go

@@ -3,31 +3,30 @@ package handlers
 import (
 	"encoding/json"
 	"errors"
-	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v3"
 	"lmika.dev/lmika/hugo-cms/models"
 	"lmika.dev/lmika/hugo-cms/services/users"
-	"net/http"
 )
 
 type AuthHandler struct {
 	UserService *users.Service
 }
 
-func (h *AuthHandler) ShowLogin(c *fiber.Ctx) error {
+func (h *AuthHandler) ShowLogin(c fiber.Ctx) error {
 	return c.Render("auth/login", fiber.Map{}, "layouts/login")
 }
 
-func (h *AuthHandler) Login(c *fiber.Ctx) error {
+func (h *AuthHandler) Login(c fiber.Ctx) error {
 	var req struct {
 		Email    string `form:"email"`
 		Password string `form:"password"`
 	}
 
-	if err := c.BodyParser(&req); err != nil {
+	if err := c.Bind().Body(&req); err != nil {
 		return errors.New("invalid email or password")
 	}
 
-	user, err := h.UserService.VerifyLogin(c.UserContext(), req.Email, req.Password)
+	user, err := h.UserService.VerifyLogin(c.Context(), req.Email, req.Password)
 	if err != nil {
 		return errors.New("invalid email or password")
 	}
@@ -41,20 +40,20 @@ func (h *AuthHandler) Login(c *fiber.Ctx) error {
 		Name:  models.AuthCookieName,
 		Value: string(bts),
 	})
-	return c.Redirect("/", http.StatusFound)
+	return c.Redirect().To("/")
 }
 
-func (h *AuthHandler) RequireAuth(c *fiber.Ctx) error {
+func (h *AuthHandler) RequireAuth(c fiber.Ctx) error {
 	user, err := h.readAuthCookie(c)
 	if err != nil {
-		return c.Redirect("/auth/login", http.StatusFound)
+		return c.Redirect().To("/auth/login")
 	}
 
 	c.Locals("user", user)
 	return c.Next()
 }
 
-func (h *AuthHandler) readAuthCookie(c *fiber.Ctx) (user models.User, err error) {
+func (h *AuthHandler) readAuthCookie(c fiber.Ctx) (user models.User, err error) {
 	authData := c.Cookies(models.AuthCookieName)
 	if authData == "" {
 		return models.User{}, errors.New("no auth cookie")
@@ -65,5 +64,5 @@ func (h *AuthHandler) readAuthCookie(c *fiber.Ctx) (user models.User, err error)
 		return models.User{}, err
 	}
 
-	return h.UserService.GetUserByID(c.UserContext(), ac.UserID)
+	return h.UserService.GetUserByID(c.Context(), ac.UserID)
 }

handlers/ctx.go

@@ -2,35 +2,26 @@ package handlers
 
 import (
 	"encoding/json"
-	"errors"
-	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v3"
 	"lmika.dev/lmika/hugo-cms/models"
 	"log"
 )
 
-func GetUser(c *fiber.Ctx) models.User {
-	u, ok := c.Locals("user").(models.User)
-	if !ok {
-		panic(errors.New("user not found in context"))
-	}
-	return u
+func GetUser(c fiber.Ctx) models.User {
+	return fiber.Locals[models.User](c, "user")
 }
 
-func GetSite(c *fiber.Ctx) models.Site {
-	s, ok := c.Locals("site").(models.Site)
-	if !ok {
-		panic(errors.New("no site in context"))
-	}
-	return s
+func GetSite(c fiber.Ctx) models.Site {
+	return fiber.Locals[models.Site](c, "site")
 }
 
-func UpdatePrefCookie(c *fiber.Ctx, update func(prefs *models.PrefCookie)) {
+func UpdatePrefCookie(c fiber.Ctx, update func(prefs *models.PrefCookie)) {
 	cookie := GetPrefCookie(c)
 	update(&cookie)
 	setPrefCookie(c, cookie)
 }
 
-func GetPrefCookie(c *fiber.Ctx) models.PrefCookie {
+func GetPrefCookie(c fiber.Ctx) models.PrefCookie {
 	prefCookieValue := c.Cookies(models.PrefCookieName)
 	if prefCookieValue == "" {
 		return models.PrefCookie{}
@@ -45,7 +36,7 @@ func GetPrefCookie(c *fiber.Ctx) models.PrefCookie {
 	return prefCookie
 }
 
-func setPrefCookie(c *fiber.Ctx, prefCookie models.PrefCookie) {
+func setPrefCookie(c fiber.Ctx, prefCookie models.PrefCookie) {
 	if prefJson, err := json.Marshal(prefCookie); err == nil {
 		c.Cookie(&fiber.Cookie{
 			Name:  models.PrefCookieName,

handlers/index.go

@@ -2,17 +2,16 @@ package handlers
 
 import (
 	"fmt"
-	"github.com/gofiber/fiber/v2"
-	"net/http"
+	"github.com/gofiber/fiber/v3"
 )
 
 type IndexHandler struct {
 }
 
-func (h IndexHandler) Index(c *fiber.Ctx) error {
+func (h IndexHandler) Index(c fiber.Ctx) error {
 	prefs := GetPrefCookie(c)
 	if prefs.SiteID > 0 {
-		return c.Redirect(fmt.Sprintf("/sites/%v/posts", prefs.SiteID), http.StatusFound)
+		return c.Redirect().To(fmt.Sprintf("/sites/%v/posts", prefs.SiteID))
 	}
 
 	return c.Render("index", fiber.Map{}, "layouts/main")

handlers/mimeselectors.go

@@ -1,33 +1,33 @@
 package handlers
 
-import "github.com/gofiber/fiber/v2"
+import "github.com/gofiber/fiber/v3"
 
 type mimeTypeHandler interface {
-	CanHandle(c *fiber.Ctx) bool
-	Handle(c *fiber.Ctx) error
+	CanHandle(c fiber.Ctx) bool
+	Handle(c fiber.Ctx) error
 }
 
-type HTMX func(c *fiber.Ctx) error
+type HTMX func(c fiber.Ctx) error
 
-func (h HTMX) CanHandle(c *fiber.Ctx) bool {
+func (h HTMX) CanHandle(c fiber.Ctx) bool {
 	return c.Get("Hx-request") == "true"
 }
 
-func (h HTMX) Handle(c *fiber.Ctx) error {
+func (h HTMX) Handle(c fiber.Ctx) error {
 	return h(c)
 }
 
-type Otherwise func(c *fiber.Ctx) error
+type Otherwise func(c fiber.Ctx) error
 
-func (h Otherwise) CanHandle(c *fiber.Ctx) bool {
+func (h Otherwise) CanHandle(c fiber.Ctx) bool {
 	return true
 }
 
-func (h Otherwise) Handle(c *fiber.Ctx) error {
+func (h Otherwise) Handle(c fiber.Ctx) error {
 	return h(c)
 }
 
-func Select(c *fiber.Ctx, mimeTypes ...mimeTypeHandler) error {
+func Select(c fiber.Ctx, mimeTypes ...mimeTypeHandler) error {
 	for _, mt := range mimeTypes {
 		if mt.CanHandle(c) {
 			return mt.Handle(c)

handlers/post.go

@@ -1,8 +1,9 @@
 package handlers
 
 import (
+	"errors"
 	"fmt"
-	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v3"
 	"lmika.dev/lmika/hugo-cms/models"
 	"lmika.dev/lmika/hugo-cms/services/posts"
 	"net/http"
@@ -12,10 +13,10 @@ type Post struct {
 	Post *posts.Service
 }
 
-func (h *Post) Posts(c *fiber.Ctx) error {
+func (h *Post) Posts(c fiber.Ctx) error {
 	site := GetSite(c)
 
-	posts, err := h.Post.ListPostOfSite(c.UserContext(), site)
+	posts, err := h.Post.ListPostOfSite(c.Context(), site)
 	if err != nil {
 		return err
 	}
@@ -25,24 +26,24 @@ func (h *Post) Posts(c *fiber.Ctx) error {
 	}, "layouts/site")
 }
 
-func (h *Post) New(c *fiber.Ctx) error {
+func (h *Post) New(c fiber.Ctx) error {
 	return c.Render("posts/new", fiber.Map{
 		"post": models.Post{},
 	}, "layouts/site")
 }
 
-func (h *Post) Create(c *fiber.Ctx) error {
+func (h *Post) Create(c fiber.Ctx) error {
 	site := GetSite(c)
 
 	var req struct {
 		Title string `json:"title" form:"title"`
 		Body  string `json:"body" form:"body"`
 	}
-	if err := c.BodyParser(&req); err != nil {
+	if err := c.Bind().Body(&req); err != nil {
 		return err
 	}
 
-	_, err := h.Post.Create(c.UserContext(), site, posts.NewPost{
+	_, err := h.Post.Create(c.Context(), site, posts.NewPost{
 		Title: req.Title,
 		Body:  req.Body,
 	})
@@ -50,18 +51,18 @@ func (h *Post) Create(c *fiber.Ctx) error {
 		return err
 	}
 
-	return c.Redirect(fmt.Sprintf("/sites/%v/posts", site.ID))
+	return c.Redirect().To(fmt.Sprintf("/sites/%v/posts", site.ID))
 }
 
-func (h *Post) Edit(c *fiber.Ctx) error {
+func (h *Post) Edit(c fiber.Ctx) error {
 	site := GetSite(c)
 
-	postID, err := c.ParamsInt("postId")
-	if err != nil {
-		return err
+	postID := fiber.Params[int](c, "postId")
+	if postID == 0 {
+		return errors.New("postId is required")
 	}
 
-	post, err := h.Post.GetPost(c.UserContext(), postID)
+	post, err := h.Post.GetPost(c.Context(), postID)
 	if err != nil {
 		return err
 	} else if post.SiteID != site.ID {
@@ -73,23 +74,23 @@ func (h *Post) Edit(c *fiber.Ctx) error {
 	}, "layouts/site")
 }
 
-func (h *Post) Update(c *fiber.Ctx) error {
+func (h *Post) Update(c fiber.Ctx) error {
 	site := GetSite(c)
 
-	postID, err := c.ParamsInt("postId")
-	if err != nil {
-		return err
+	postID := fiber.Params[int](c, "postId")
+	if postID == 0 {
+		return errors.New("postId is required")
 	}
 
 	var req struct {
 		Title string `json:"title" form:"title"`
 		Body  string `json:"body" form:"body"`
 	}
-	if err := c.BodyParser(&req); err != nil {
+	if err := c.Bind().Body(&req); err != nil {
 		return err
 	}
 
-	post, err := h.Post.GetPost(c.UserContext(), postID)
+	post, err := h.Post.GetPost(c.Context(), postID)
 	if err != nil {
 		return err
 	} else if post.SiteID != site.ID {
@@ -99,31 +100,31 @@ func (h *Post) Update(c *fiber.Ctx) error {
 	post.Title = req.Title
 	post.Body = req.Body
 
-	if err := h.Post.Save(c.UserContext(), site, &post); err != nil {
+	if err := h.Post.Save(c.Context(), site, &post); err != nil {
 		return err
 	}
 
-	return c.Redirect(fmt.Sprintf("/sites/%v/posts", site.ID))
+	return c.Redirect().To(fmt.Sprintf("/sites/%v/posts", site.ID))
 }
 
-func (h *Post) Delete(c *fiber.Ctx) error {
+func (h *Post) Delete(c fiber.Ctx) error {
 	site := GetSite(c)
 
-	postID, err := c.ParamsInt("postId")
-	if err != nil {
-		return err
+	postID := fiber.Params[int](c, "postId")
+	if postID == 0 {
+		return errors.New("postId is required")
 	}
 
-	if err := h.Post.DeletePost(c.UserContext(), site, postID); err != nil {
+	if err := h.Post.DeletePost(c.Context(), site, postID); err != nil {
 		return err
 	}
 
 	return Select(c,
-		HTMX(func(c *fiber.Ctx) error {
+		HTMX(func(c fiber.Ctx) error {
 			return c.Status(http.StatusOK).SendString("")
 		}),
-		Otherwise(func(c *fiber.Ctx) error {
-			return c.Redirect(fmt.Sprintf("/sites/%v/posts", site.ID), http.StatusSeeOther)
+		Otherwise(func(c fiber.Ctx) error {
+			return c.Redirect().To(fmt.Sprintf("/sites/%v/posts", site.ID))
 		}),
 	)
 }

handlers/site.go

@@ -1,11 +1,13 @@
 package handlers
 
 import (
+	"bufio"
 	"errors"
 	"fmt"
-	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v3"
 	"github.com/jackc/pgx/v5"
 	"lmika.dev/lmika/hugo-cms/models"
+	"lmika.dev/lmika/hugo-cms/providers/bus"
 	"lmika.dev/lmika/hugo-cms/services/sites"
 	"net/http"
 	"time"
@@ -13,12 +15,13 @@ import (
 
 type Site struct {
 	Site *sites.Service
+	Bus  *bus.Bus
 }
 
-func (s *Site) Create(c *fiber.Ctx) error {
+func (s *Site) Create(c fiber.Ctx) error {
 	user := GetUser(c)
 
-	site, err := s.Site.CreateSite(c.UserContext(), user, "New Site "+time.Now().Format("2006-01-02 15:04:05"))
+	site, err := s.Site.CreateSite(c.Context(), user, "New Site "+time.Now().Format("2006-01-02 15:04:05"))
 	if err != nil {
 		return err
 	}
@@ -27,16 +30,16 @@ func (s *Site) Create(c *fiber.Ctx) error {
 		prefs.SiteID = site.ID
 	})
 
-	return c.Redirect(fmt.Sprintf("/sites/%v/posts", site.ID))
+	return c.Redirect().To(fmt.Sprintf("/sites/%v/posts", site.ID))
 }
 
-func (s *Site) Show(c *fiber.Ctx) error {
-	id, err := c.ParamsInt("siteId")
-	if err != nil {
-		return err
+func (s *Site) Show(c fiber.Ctx) error {
+	id := fiber.Params[int](c, "siteId")
+	if id == 0 {
+		return errors.New("siteId is required")
 	}
 
-	site, err := s.Site.GetSite(c.UserContext(), id)
+	site, err := s.Site.GetSite(c.Context(), id)
 	if err != nil {
 		return err
 	}
@@ -46,17 +49,25 @@ func (s *Site) Show(c *fiber.Ctx) error {
 	}, "layouts/main")
 }
 
-func (s *Site) Settings(c *fiber.Ctx) error {
+func (s *Site) Settings(c fiber.Ctx) error {
+	site := GetUser(c)
+
+	prodTarget, err := s.Site.GetProdTargetOfSite(c.Context(), int(site.ID))
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return err
+	}
+
 	return c.Render("sites/settings", fiber.Map{
 		"themes": s.Site.Themes(),
+		"target": prodTarget,
 	}, "layouts/site")
 }
 
-func (s *Site) SaveSettings(c *fiber.Ctx) error {
+func (s *Site) SaveSettings(c fiber.Ctx) error {
 	site := GetSite(c)
 
 	var req sites.NewSettings
-	if err := c.BodyParser(&req); err != nil {
+	if err := c.Bind().Body(&req); err != nil {
 		return err
 	}
 
@@ -64,25 +75,60 @@ func (s *Site) SaveSettings(c *fiber.Ctx) error {
 		return err
 	}
 
-	return c.Redirect(fmt.Sprintf("/sites/%v/settings", site.ID))
+	return c.Redirect().To(fmt.Sprintf("/sites/%v/settings", site.ID))
 }
 
-func (s *Site) Rebuild(c *fiber.Ctx) error {
-	if err := s.Site.Rebuild(c.UserContext(), GetSite(c)); err != nil {
+func (s *Site) Rebuild(c fiber.Ctx) error {
+	if err := s.Site.Rebuild(c.Context(), GetSite(c)); err != nil {
 		return err
 	}
 
-	return c.Redirect(fmt.Sprintf("/sites/%v/posts", GetSite(c).ID))
+	return c.Redirect().To(fmt.Sprintf("/sites/%v/posts", GetSite(c).ID))
+}
+
+func (s *Site) SSE(c fiber.Ctx) error {
+	siteOfInterest := GetSite(c)
+
+	c.Set("Content-Type", "text/event-stream")
+	c.Set("Cache-Control", "no-cache")
+	c.Set("Connection", "keep-alive")
+	c.Set("Transfer-Encoding", "chunked")
+
+	return c.SendStreamWriter(func(w *bufio.Writer) {
+		sub := s.Bus.Subscribe()
+		defer s.Bus.Unsubscribe(sub)
+
+		for e := range sub.C {
+			switch e.Type {
+			case models.EventSiteBuildingStart:
+				eventSite := e.Data.(models.Site)
+				if eventSite.ID == siteOfInterest.ID {
+					fmt.Fprintf(w, "event: site-build-status\n")
+					fmt.Fprintf(w, "data: Building\n")
+				}
+			case models.EventSiteBuildingDone:
+				eventSite := e.Data.(models.Site)
+				if eventSite.ID == siteOfInterest.ID {
+					fmt.Fprintf(w, "event: site-build-status\n")
+					fmt.Fprintf(w, "data: \n")
+				}
+			}
+
+			if err := w.Flush(); err != nil {
+				break
+			}
+		}
+	})
 }
 
 func (s *Site) WithSite() fiber.Handler {
-	return func(c *fiber.Ctx) (err error) {
-		id, err := c.ParamsInt("siteId")
-		if err != nil {
-			return err
+	return func(c fiber.Ctx) (err error) {
+		id := fiber.Params[int](c, "siteId")
+		if id == 0 {
+			return errors.New("siteId is required")
 		}
 
-		site, err := s.Site.GetSite(c.UserContext(), id)
+		site, err := s.Site.GetSite(c.Context(), id)
 		if err != nil {
 			return err
 		}
@@ -94,7 +140,7 @@ func (s *Site) WithSite() fiber.Handler {
 
 		c.Locals("site", site)
 
-		if prodTarget, err := s.Site.GetProdTargetOfSite(c.UserContext(), int(site.ID)); err == nil {
+		if prodTarget, err := s.Site.GetProdTargetOfSite(c.Context(), int(site.ID)); err == nil {
 			c.Locals("prodTarget", prodTarget)
 		} else if !errors.Is(err, pgx.ErrNoRows) {
 			return err

main.go

@@ -5,15 +5,16 @@ import (
 	"context"
 	"flag"
 	"fmt"
-	"github.com/gofiber/fiber/v2"
-	"github.com/gofiber/fiber/v2/middleware/encryptcookie"
-	"github.com/gofiber/fiber/v2/middleware/filesystem"
+	"github.com/gofiber/fiber/v3"
+	"github.com/gofiber/fiber/v3/middleware/encryptcookie"
+	"github.com/gofiber/fiber/v3/middleware/static"
 	"github.com/gofiber/template/html/v2"
 	"github.com/yuin/goldmark"
 	"html/template"
 	"lmika.dev/lmika/hugo-cms/assets"
 	"lmika.dev/lmika/hugo-cms/config"
 	"lmika.dev/lmika/hugo-cms/handlers"
+	"lmika.dev/lmika/hugo-cms/providers/bus"
 	"lmika.dev/lmika/hugo-cms/providers/db"
 	"lmika.dev/lmika/hugo-cms/providers/git"
 	"lmika.dev/lmika/hugo-cms/providers/hugo"
@@ -36,7 +37,7 @@ func main() {
 	flag.Parse()
 
 	if *flagGenKey {
-		fmt.Println(encryptcookie.GenerateKey())
+		fmt.Println(encryptcookie.GenerateKey(32))
 		return
 	}
 
@@ -77,15 +78,16 @@ func main() {
 	gitProvider := git.New()
 	themesProvider := themes.New()
 	netlifyProvider := netlify.New(cfg.NetlifyAuthToken)
+	bus := bus.New()
 
 	jobService := jobs.New()
-	siteBuilderService := sitebuilder.New(dbp, themesProvider, gitProvider, hugoProvider, netlifyProvider)
+	siteBuilderService := sitebuilder.New(dbp, themesProvider, gitProvider, hugoProvider, netlifyProvider, bus)
 
 	siteService := sites.NewService(cfg, dbp, themesProvider, siteBuilderService, jobService)
 	postService := posts.New(dbp, siteBuilderService, jobService)
 
 	indexHandlers := handlers.IndexHandler{}
-	siteHandlers := handlers.Site{Site: siteService}
+	siteHandlers := handlers.Site{Site: siteService, Bus: bus}
 	postHandlers := handlers.Post{Post: postService}
 	authHandlers := handlers.AuthHandler{UserService: userService}
 
@@ -100,16 +102,21 @@ func main() {
 
 	if cfg.EncryptedCookieKey == "" {
 		log.Println("No encrypt cookie key defined. Generating random key")
-		cfg.EncryptedCookieKey = encryptcookie.GenerateKey()
+		cfg.EncryptedCookieKey = encryptcookie.GenerateKey(32)
 	}
 
+	bus.Start()
+	defer bus.Stop()
+
 	app := fiber.New(fiber.Config{
 		Views:             tmplEngine,
 		PassLocalsToViews: true,
 	})
 	app.Use(encryptcookie.New(encryptcookie.Config{Key: cfg.EncryptedCookieKey}))
 
-	app.Use("/assets", filesystem.New(filesystem.Config{Root: http.FS(assets.FS)}))
+	app.Use("/assets", static.New("", static.Config{
+		FS: assets.FS,
+	}))
 
 	app.Get("/auth/login", authHandlers.ShowLogin)
 	app.Post("/auth/login", authHandlers.Login)
@@ -119,20 +126,20 @@ func main() {
 	app.Post("/sites", siteHandlers.Create)
 	app.Get("/sites/:siteId", siteHandlers.Show)
 
-	app.Route("/sites/:siteId", func(r fiber.Router) {
-		r.Use(siteHandlers.WithSite())
-		r.Post("/rebuild", siteHandlers.Rebuild)
+	sr := app.Group("/sites/:siteId")
+	sr.Use(siteHandlers.WithSite())
+	sr.Post("/rebuild", siteHandlers.Rebuild)
 
-		r.Get("/posts", postHandlers.Posts)
-		r.Get("/posts/new", postHandlers.New)
-		r.Post("/posts", postHandlers.Create)
-		r.Get("/posts/:postId", postHandlers.Edit)
-		r.Post("/posts/:postId", postHandlers.Update)
-		r.Delete("/posts/:postId", postHandlers.Delete)
+	sr.Get("/posts", postHandlers.Posts)
+	sr.Get("/posts/new", postHandlers.New)
+	sr.Post("/posts", postHandlers.Create)
+	sr.Get("/posts/:postId", postHandlers.Edit)
+	sr.Post("/posts/:postId", postHandlers.Update)
+	sr.Delete("/posts/:postId", postHandlers.Delete)
 
-		r.Get("/settings", siteHandlers.Settings)
-		r.Post("/settings", siteHandlers.SaveSettings)
-	})
+	sr.Get("/settings", siteHandlers.Settings)
+	sr.Post("/settings", siteHandlers.SaveSettings)
+	sr.Get("/sse", siteHandlers.SSE)
 
 	jobService.Start()
 	defer jobService.Stop()

models/events.go

@@ -0,0 +1,31 @@
+package models
+
+import "container/list"
+
+type EventType int
+
+const (
+	// EventTypeSubscribe event type for the bus indicating a new subscription.
+	// Data is a (chan Sub) to send the new subscription
+	EventTypeSubscribe EventType = iota
+
+	// EventTypeUnsubscribe event type for the bus indicating to remove a subscription.
+	// Data is the Sub type
+	EventTypeUnsubscribe
+
+	// EventSiteBuildingStart indicates that the site has started being built. Data = site
+	EventSiteBuildingStart = 2
+
+	// EventSiteBuildingDone indicates that the site has finish building. Data = site
+	EventSiteBuildingDone = 3
+)
+
+type Event struct {
+	Type EventType
+	Data any
+}
+
+type Sub struct {
+	C    chan Event
+	Elem *list.Element
+}

models/job.go

@@ -5,14 +5,3 @@ import "context"
 type Job struct {
 	Do func(ctx context.Context) error
 }
-
-func Jobs(jobs ...Job) Job {
-	return Job{Do: func(ctx context.Context) error {
-		for _, job := range jobs {
-			if err := job.Do(ctx); err != nil {
-				return err
-			}
-		}
-		return nil
-	}}
-}

providers/bus/bus.go

@@ -0,0 +1,64 @@
+package bus
+
+import (
+	"container/list"
+	"lmika.dev/lmika/hugo-cms/models"
+)
+
+type Bus struct {
+	subs       *list.List
+	eventQueue chan models.Event
+}
+
+func New() *Bus {
+	return &Bus{
+		subs:       list.New(),
+		eventQueue: make(chan models.Event, 20),
+	}
+}
+
+func (b *Bus) Fire(event models.Event) {
+	b.eventQueue <- event
+}
+
+func (b *Bus) Start() {
+	go func() {
+		for e := range b.eventQueue {
+			switch e.Type {
+			case models.EventTypeSubscribe:
+				retChan := e.Data.(chan *models.Sub)
+
+				newSub := &models.Sub{C: make(chan models.Event, 1)}
+				newSub.Elem = b.subs.PushBack(newSub)
+
+				retChan <- newSub
+			case models.EventTypeUnsubscribe:
+				sub := e.Data.(*models.Sub)
+				close(sub.C)
+				b.subs.Remove(sub.Elem)
+			default:
+				for f := b.subs.Front(); f != nil; f = f.Next() {
+					sub := f.Value.(*models.Sub)
+					select {
+					case sub.C <- e:
+					default:
+					}
+				}
+			}
+		}
+	}()
+}
+
+func (b *Bus) Stop() {
+	close(b.eventQueue)
+}
+
+func (b *Bus) Subscribe() *models.Sub {
+	resChan := make(chan *models.Sub)
+	b.eventQueue <- models.Event{Type: models.EventTypeSubscribe, Data: resChan}
+	return <-resChan
+}
+
+func (b *Bus) Unsubscribe(sub *models.Sub) {
+	b.eventQueue <- models.Event{Type: models.EventTypeUnsubscribe, Data: sub}
+}

services/sitebuilder/posts.go

@@ -15,11 +15,14 @@ import (
 func (s *Service) WritePost(site models.Site, post models.Post) models.Job {
 	return models.Job{
 		Do: func(ctx context.Context) error {
+			s.signalSiteBuildingStarted(ctx, site)
+			defer s.signalSiteBuildingFinished(ctx, site)
+
 			rbn, err := s.fullRebuildNecessary(ctx, site)
 			if err != nil {
 				return err
 			} else if rbn {
-				return s.RebuildSite(site, site).Do(ctx)
+				return s.rebuildSite(ctx, site, site)
 			}
 
 			if err := s.writePost(site, post); err != nil {
@@ -33,53 +36,64 @@ func (s *Service) WritePost(site models.Site, post models.Post) models.Job {
 func (s *Service) WriteAllPosts(site models.Site) models.Job {
 	return models.Job{
 		Do: func(ctx context.Context) error {
-			var startId int64
-			now := time.Now()
-			for {
-				posts, err := s.db.ListPublishablePosts(ctx, int64(startId), site.ID, now)
-				if err != nil {
-					return err
-				} else if len(posts) == 0 {
-					return nil
-				}
+			s.signalSiteBuildingStarted(ctx, site)
+			defer s.signalSiteBuildingFinished(ctx, site)
 
-				for _, post := range posts {
-					if err := s.writePost(site, post); err != nil {
-						return err
-					}
-				}
-				startId = posts[len(posts)-1].ID
+			if err := s.writeAllPosts(ctx, site); err != nil {
+				return err
 			}
+
+			return s.publish(ctx, site)
 		},
 	}
 }
 
 func (s *Service) DeletePost(site models.Site, post models.Post) models.Job {
-	return models.Jobs(
-		models.Job{
-			Do: func(ctx context.Context) error {
-				themeMeta, ok := s.themes.Lookup(site.Theme)
-				if !ok {
-					return errors.New("theme not found")
-				}
+	return models.Job{
+		Do: func(ctx context.Context) error {
+			s.signalSiteBuildingStarted(ctx, site)
+			defer s.signalSiteBuildingFinished(ctx, site)
 
-				postFilename := s.postFilename(site, themeMeta, post)
+			themeMeta, ok := s.themes.Lookup(site.Theme)
+			if !ok {
+				return errors.New("theme not found")
+			}
 
-				if _, err := os.Stat(postFilename); err != nil {
-					if errors.Is(err, os.ErrNotExist) {
-						return nil
-					}
-					return err
-				}
+			postFilename := s.postFilename(site, themeMeta, post)
 
-				if os.Remove(postFilename) != nil {
+			if _, err := os.Stat(postFilename); err != nil {
+				if errors.Is(err, os.ErrNotExist) {
 					return nil
 				}
+				return err
+			}
+
+			if os.Remove(postFilename) != nil {
 				return nil
-			},
+			}
+			return s.publish(ctx, site)
 		},
-		s.Publish(site),
-	)
+	}
+}
+
+func (s *Service) writeAllPosts(ctx context.Context, site models.Site) error {
+	var startId int64
+	now := time.Now()
+	for {
+		posts, err := s.db.ListPublishablePosts(ctx, int64(startId), site.ID, now)
+		if err != nil {
+			return err
+		} else if len(posts) == 0 {
+			return nil
+		}
+
+		for _, post := range posts {
+			if err := s.writePost(site, post); err != nil {
+				return err
+			}
+		}
+		startId = posts[len(posts)-1].ID
+	}
 }
 
 func (s *Service) writePost(site models.Site, post models.Post) error {

services/sitebuilder/publish.go

@@ -8,6 +8,9 @@ import (
 func (s *Service) Publish(site models.Site) models.Job {
 	return models.Job{
 		Do: func(ctx context.Context) error {
+			s.signalSiteBuildingStarted(ctx, site)
+			defer s.signalSiteBuildingFinished(ctx, site)
+			
 			return s.publish(ctx, site)
 		},
 	}

services/sitebuilder/service.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"lmika.dev/lmika/hugo-cms/models"
+	"lmika.dev/lmika/hugo-cms/providers/bus"
 	"lmika.dev/lmika/hugo-cms/providers/db"
 	"lmika.dev/lmika/hugo-cms/providers/git"
 	"lmika.dev/lmika/hugo-cms/providers/hugo"
@@ -20,6 +21,7 @@ type Service struct {
 	git     *git.Provider
 	hugo    *hugo.Provider
 	netlify *netlify.Provider
+	bus     *bus.Bus
 }
 
 func New(
@@ -28,6 +30,7 @@ func New(
 	git *git.Provider,
 	hugo *hugo.Provider,
 	netlify *netlify.Provider,
+	bus *bus.Bus,
 ) *Service {
 	return &Service{
 		db:      db,
@@ -35,33 +38,48 @@ func New(
 		git:     git,
 		hugo:    hugo,
 		netlify: netlify,
+		bus:     bus,
 	}
 }
 
 func (s *Service) CreateNewSite(site models.Site) models.Job {
 	return models.Job{
 		Do: func(ctx context.Context) error {
+			s.signalSiteBuildingStarted(ctx, site)
+			defer s.signalSiteBuildingFinished(ctx, site)
+
 			return s.createSite(ctx, site)
 		},
 	}
 }
 
 func (s *Service) RebuildSite(oldSite, newSite models.Site) models.Job {
-	return models.Jobs(
-		models.Job{
-			Do: func(ctx context.Context) error {
-				// Teardown the existing site
-				siteDir := s.hugo.SiteStagingDir(oldSite, hugo.BaseSiteDir)
-				if err := os.RemoveAll(siteDir); err != nil {
-					return err
-				}
-				return nil
-			},
+	return models.Job{
+		Do: func(ctx context.Context) error {
+			s.signalSiteBuildingStarted(ctx, newSite)
+			defer s.signalSiteBuildingFinished(ctx, newSite)
+
+			return s.rebuildSite(ctx, oldSite, newSite)
 		},
-		s.CreateNewSite(newSite),
-		s.WriteAllPosts(newSite),
-		s.Publish(newSite),
-	)
+	}
+}
+
+func (s *Service) rebuildSite(ctx context.Context, oldSite, newSite models.Site) error {
+	// Teardown the existing site
+	siteDir := s.hugo.SiteStagingDir(oldSite, hugo.BaseSiteDir)
+	if err := os.RemoveAll(siteDir); err != nil {
+		return err
+	}
+
+	if err := s.createSite(ctx, newSite); err != nil {
+		return err
+	}
+
+	if err := s.writeAllPosts(ctx, newSite); err != nil {
+		return err
+	}
+
+	return s.publish(ctx, newSite)
 }
 
 func (s *Service) fullRebuildNecessary(ctx context.Context, site models.Site) (bool, error) {
@@ -122,3 +140,11 @@ func (s *Service) createSite(ctx context.Context, site models.Site) error {
 	}
 	return nil
 }
+
+func (s *Service) signalSiteBuildingStarted(ctx context.Context, site models.Site) {
+	s.bus.Fire(models.Event{Type: models.EventSiteBuildingStart, Data: site})
+}
+
+func (s *Service) signalSiteBuildingFinished(ctx context.Context, site models.Site) {
+	s.bus.Fire(models.Event{Type: models.EventSiteBuildingDone, Data: site})
+}

templates/layouts/site.html

@@ -7,6 +7,7 @@
     <link rel="stylesheet" href="/assets/css/main.css">
     <title>Hugo CMS</title>
     <script src="https://unpkg.com/htmx.org@2.0.4"></script>
+    <script src="https://unpkg.com/htmx-ext-sse@2.2.2/sse.js"></script>
 </head>
 <body class="role-site">
     <header>