commiting work on attempting to work towards an embedded html setup

Makefile

@@ -6,8 +6,7 @@ SEED_CMD = seed
 SWAG := $(shell command -v swag 2> /dev/null)
 ## Have to set the WEB_ROOT and DOMAIN_NAME environment variables when building
 build:
-	go build -ldflags "-X main.WEB_ROOT=$(WEB_ROOT) \
-	-X main.DOMAIN_NAME=$(DOMAIN_NAME)" \
+	go build -ldflags " -X main.DOMAIN_NAME=$(DOMAIN_NAME)" \
 	-o ./build/linux/$(WEBSERVER)/$(WEBSERVER) ./cmd/$(WEBSERVER)/$(WEBSERVER).go
 
 format:
@@ -25,4 +24,4 @@ build-seed-cmd:
 dev-run:
 	go build -ldflags "-X main.WEB_ROOT=$(WEB_ROOT)" \
 	-o ./build/linux/$(WEBSERVER)/$(WEBSERVER) ./cmd/$(WEBSERVER)/$(WEBSERVER).go && \
-	./build/linux/$(WEBSERVER)/$(WEBSERVER) .env
+	./build/linux/$(WEBSERVER)/$(WEBSERVER) .env

cmd/webserver/webserver.go

@@ -1,26 +1,28 @@
 package main
 
 import (
+	"database/sql"
+	"flag"
 	"fmt"
 	"log"
 	"os"
-	"database/sql"
 
 	"github.com/gin-contrib/multitemplate"
 	"github.com/gin-gonic/gin"
 
 	"git.aetherial.dev/aeth/keiji/pkg/env"
-	"git.aetherial.dev/aeth/keiji/pkg/routes"
 	"git.aetherial.dev/aeth/keiji/pkg/helpers"
+	"git.aetherial.dev/aeth/keiji/pkg/routes"
+	"git.aetherial.dev/aeth/keiji/pkg/webpages"
 
 	_ "github.com/mattn/go-sqlite3"
 )
 
-var WEB_ROOT string
 var DOMAIN_NAME string
 
-
 func main() {
+	htmlSrc := flag.String("html-src", "", "Force the server to serve embedded content, for production use")
+	flag.Parse()
 	args := os.Args
 	err := env.LoadAndVerifyEnv(args[1], env.REQUIRED_VARS)
 	if err != nil {
@@ -28,101 +30,73 @@ func main() {
 	}
 	REDIS_PORT := os.Getenv("REDIS_PORT")
 	REDIS_ADDR := os.Getenv("REDIS_ADDR")
-	renderer := multitemplate.NewRenderer()
-	renderer.AddFromFiles(
+	var srcOpt webpages.ServiceOption
+	if *htmlSrc == "filesystem" {
+		srcOpt = webpages.FILESYSTEM
+	}
+	if *htmlSrc == "embed" {
+		srcOpt = webpages.EMBED
+	}
+	fmt.Println(srcOpt, *htmlSrc)
+	// htmlReader := webpages.NewContentLayer(webpages.ServiceOption(webpages.FILESYSTEM))
+	htmlReader := webpages.FilesystemWebpages{Webroot: os.Getenv("WEB_ROOT")}
+	renderer := multitemplate.NewDynamic()
+	renderer.AddFromString(
+		"head",
+		webpages.ReadToString(htmlReader, "head.html"),
+	)
+	renderer.AddFromString(
+		"navigation",
+		webpages.ReadToString(htmlReader, "navigation.html"),
+	)
+	renderer.AddFromString(
 		"home",
-		fmt.Sprintf("%s/templates/home.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/writing.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/menu.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/link.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/listing.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/head.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "home.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"blogpost",
-		fmt.Sprintf("%s/templates/blogpost.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/menu.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/link.html", WEB_ROOT),
-
+		webpages.ReadToString(htmlReader, "blogpost.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"digital_art",
-		fmt.Sprintf("%s/templates/digital_art.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/centered_image.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/menu.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/link.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "digital_art.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"login",
-		fmt.Sprintf("%s/templates/login.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "login.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"admin",
-		fmt.Sprintf("%s/templates/admin.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/menu.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/link.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/listing.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/blogpost_editor.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "admin.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"blogpost_editor",
-		fmt.Sprintf("%s/templates/blogpost_editor.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/menu.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/link.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/upload_status.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/listing.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "blogpost_editor.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"new_blogpost",
-		fmt.Sprintf("%s/templates/new_blogpost.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/menu.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/link.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/upload_status.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/listing.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "new_blogpost.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"upload_status",
-		fmt.Sprintf("%s/templates/upload_status.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "upload_status.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"unhandled_error",
-		fmt.Sprintf("%s/templates/unhandled_error.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/menu.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/link.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/listing.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "unhandled_error.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"upload",
-		fmt.Sprintf("%s/templates/upload.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/menu.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/link.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/listing.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "upload.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"writing",
-		/*
-		fmt.Sprintf("%s/templates/listing.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/navigation.html", WEB_ROOT),
-		fmt.Sprintf("%s/templates/head.html", WEB_ROOT),
-		*/
-		fmt.Sprintf("%s/templates/writing.html", WEB_ROOT),
+		webpages.ReadToString(htmlReader, "writing.html"),
 	)
-	renderer.AddFromFiles(
+	renderer.AddFromString(
 		"listing",
-		fmt.Sprintf("%s/templates/listing.html", WEB_ROOT),
-		)
-	renderer.AddFromFiles(
-		"head",
-		fmt.Sprintf("%s/templates/head.html", WEB_ROOT),
-		)
+		webpages.ReadToString(htmlReader, "listing.html"),
+	)
 	e := gin.Default()
 	dbfile := "sqlite.db"
 	db, err := sql.Open("sqlite3", dbfile)
@@ -130,15 +104,16 @@ func main() {
 		log.Fatal(err)
 	}
 	e.HTMLRender = renderer
+	// 	e.LoadHTMLGlob("pkg/webpages/html/*.html")
 	webserverDb := helpers.NewSQLiteRepo(db)
 	err = webserverDb.Migrate()
 	if err != nil {
 		log.Fatal(err)
 	}
-	routes.Register(e, WEB_ROOT, DOMAIN_NAME, REDIS_PORT, REDIS_ADDR, webserverDb)
+	routes.Register(e, DOMAIN_NAME, REDIS_PORT, REDIS_ADDR, webserverDb)
 	if os.Getenv("SSL_MODE") == "ON" {
 		e.RunTLS(fmt.Sprintf("%s:%s", os.Getenv("HOST_ADDR"), os.Getenv("HOST_PORT")),
-		os.Getenv(env.CHAIN), os.Getenv(env.KEY))
+			os.Getenv(env.CHAIN), os.Getenv(env.KEY))
 	}
 	e.Run(fmt.Sprintf("%s:%s", os.Getenv("HOST_ADDR"), os.Getenv("HOST_PORT")))
 }

pkg/controller/cdn_handlers.go

@@ -2,10 +2,10 @@ package controller
 
 import (
 	"fmt"
+	"net/http"
 	"os"
 	"path"
 	"strings"
-	"net/http"
 
 	"git.aetherial.dev/aeth/keiji/pkg/helpers"
 	"github.com/gin-gonic/gin"
@@ -49,15 +49,13 @@ func (c *Controller) ServeAsset(ctx *gin.Context) {
 	for i := range assets {
 		if strings.Contains(assets[i].Name, f) {
 			ctx.Data(200, "image/png", assets[i].Data)
-			return 
+			return
 		}
 	}
 	ctx.Data(http.StatusNotFound, "text", []byte("Couldnt find the image requested."))
 
 }
 
-
-
 // @Name ServeGeneric
 // @Summary serves file from the html file
 // @Tags cdn
@@ -84,7 +82,7 @@ func (c *Controller) ServeGeneric(ctx *gin.Context) {
 	default:
 		ctype = "text"
 	}
-	b, err := os.ReadFile(path.Join(c.WebRoot, f))
+	b, err := os.ReadFile(path.Join("html", f))
 	if err != nil {
 		ctx.JSON(500, map[string]string{
 			"Error": "Could not serve the requested file",

pkg/controller/controller.go

@@ -1,30 +1,22 @@
 package controller
 
 import (
-
 	"git.aetherial.dev/aeth/keiji/pkg/helpers"
 )
 
-type Controller struct{
-	WebRoot		string
-	Domain		string
+type Controller struct {
+	Domain      string
 	database    helpers.DocumentIO
 	RedisConfig helpers.RedisConf
-	Cache		*helpers.AllCache
+	Cache       *helpers.AllCache
 }
 
-
-
-
-
-
-
-func NewController(root string, domain string, redisPort string, redisAddr string, database helpers.DocumentIO) *Controller {
-	return &Controller{WebRoot: root, Cache: helpers.NewCache(),
-								Domain: domain, RedisConfig: helpers.RedisConf{
-																		Port: redisPort,
-																		Addr: redisAddr,
-																		},
-																		database: database,
-																	}
+func NewController(domain string, redisPort string, redisAddr string, database helpers.DocumentIO) *Controller {
+	return &Controller{Cache: helpers.NewCache(),
+		Domain: domain, RedisConfig: helpers.RedisConf{
+			Port: redisPort,
+			Addr: redisAddr,
+		},
+		database: database,
+	}
 }

pkg/routes/register.go

@@ -6,8 +6,8 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func Register(e *gin.Engine, root string, domain string, redisPort string, redisAddr string, database helpers.DocumentIO) {
-	c := controller.NewController(root, domain, redisPort, redisAddr, database)
+func Register(e *gin.Engine, domain string, redisPort string, redisAddr string, database helpers.DocumentIO) {
+	c := controller.NewController(domain, redisPort, redisAddr, database)
 	web := e.Group("")
 	web.GET("/", c.ServeHome)
 	web.GET("/blog", c.ServeBlog)
@@ -16,14 +16,11 @@ func Register(e *gin.Engine, root string, domain string, redisPort string, redis
 	web.GET("/login", c.ServeLogin)
 	web.POST("/login", c.Auth)
 
-
 	cdn := e.Group("/api/v1")
 	cdn.GET("/images/:file", c.ServeImage)
 	cdn.GET("/cdn/:file", c.ServeGeneric)
 	cdn.GET("assets/:file", c.ServeAsset)
 
-
-
 	priv := e.Group("/admin")
 	priv.Use(c.IsAuthenticated)
 	priv.GET("/upload", c.ServeFileUpload)

pkg/webpages/pages.go

@@ -0,0 +1,71 @@
+package webpages
+
+import (
+	"embed"
+	_ "embed"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"os"
+	"path"
+)
+
+//go:embed html
+var content embed.FS
+
+type ServiceOption string
+
+const EMBED ServiceOption = "embed"
+const FILESYSTEM ServiceOption = "filesystem"
+
+/*
+Creates the new filesystem implementer for serving the webpages to the API
+
+	:param opt: the service option to
+*/
+func NewContentLayer(opt ServiceOption) fs.FS {
+	if opt == EMBED {
+		return content
+	}
+	if opt == FILESYSTEM {
+		fmt.Println(os.Getenv("WEB_ROOT"))
+		return FilesystemWebpages{Webroot: path.Base(os.Getenv("WEB_ROOT"))}
+	}
+	log.Fatal("Unknown option was passed: ", opt)
+	return content
+
+}
+
+type WebContentLayer interface{}
+
+type EmbeddedWebpages struct{}
+
+type FilesystemWebpages struct {
+	Webroot string
+}
+
+/*
+Implementing the io.FS interface for interoperability
+*/
+func (f FilesystemWebpages) Open(file string) (fs.File, error) {
+	fmt.Println(path.Join(f.Webroot, file))
+	return os.Open(path.Join(f.Webroot, file))
+}
+
+/*
+Read content to a string for easy template ingestion. Will panic if the underlying os.Open call fails
+*/
+func ReadToString(rdr fs.FS, name string) string {
+	fh, err := rdr.Open(name)
+	if err != nil {
+		log.Fatal(err, "couldnt open the file: ", name)
+	}
+	b, err := io.ReadAll(fh)
+
+	if err != nil {
+		log.Fatal("Could not read the file: ", name)
+	}
+	return string(b)
+
+}