Use bundled images instead of old webroot files

controllers/emoji.go

@@ -2,59 +2,60 @@ package controllers
 
 import (
 	"encoding/json"
+	"io/fs"
 	"net/http"
-	"os"
-	"path"
 	"path/filepath"
 	"strings"
-	"time"
 
 	"github.com/owncast/owncast/config"
 	"github.com/owncast/owncast/models"
+	"github.com/owncast/owncast/static"
+	"github.com/owncast/owncast/utils"
 	log "github.com/sirupsen/logrus"
 )
 
-var (
-	emojiCache          = make([]models.CustomEmoji, 0)
-	emojiCacheTimestamp time.Time
-)
-
 // getCustomEmojiList returns a list of custom emoji either from the cache or from the emoji directory.
 func getCustomEmojiList() []models.CustomEmoji {
-	fullPath := filepath.Join(config.WebRoot, config.EmojiDir)
-	emojiDirInfo, err := os.Stat(fullPath)
+	bundledEmoji := static.GetEmoji()
+	emojiResponse := make([]models.CustomEmoji, 0)
+
+	files, err := fs.Glob(bundledEmoji, "*")
 	if err != nil {
 		log.Errorln(err)
-	}
-	if emojiDirInfo.ModTime() != emojiCacheTimestamp {
-		log.Traceln("Emoji cache invalid")
-		emojiCache = make([]models.CustomEmoji, 0)
+		return emojiResponse
 	}
 
-	if len(emojiCache) == 0 {
-		files, err := os.ReadDir(fullPath)
-		if err != nil {
-			log.Errorln(err)
-			return emojiCache
-		}
-		for _, f := range files {
-			name := strings.TrimSuffix(f.Name(), path.Ext(f.Name()))
-			emojiPath := filepath.Join(config.EmojiDir, f.Name())
-			singleEmoji := models.CustomEmoji{Name: name, URL: emojiPath}
-			emojiCache = append(emojiCache, singleEmoji)
-		}
-
-		emojiCacheTimestamp = emojiDirInfo.ModTime()
+	for _, name := range files {
+		emojiPath := filepath.Join(config.EmojiDir, name)
+		singleEmoji := models.CustomEmoji{Name: name, URL: emojiPath}
+		emojiResponse = append(emojiResponse, singleEmoji)
 	}
 
-	return emojiCache
+	return emojiResponse
 }
 
-// GetCustomEmoji returns a list of custom emoji via the API.
-func GetCustomEmoji(w http.ResponseWriter, r *http.Request) {
+// GetCustomEmojiList returns a list of custom emoji via the API.
+func GetCustomEmojiList(w http.ResponseWriter, r *http.Request) {
 	emojiList := getCustomEmojiList()
 
 	if err := json.NewEncoder(w).Encode(emojiList); err != nil {
 		InternalErrorHandler(w, err)
 	}
 }
+
+// GetCustomEmojiImage returns a single emoji image.
+func GetCustomEmojiImage(w http.ResponseWriter, r *http.Request) {
+	bundledEmoji := static.GetEmoji()
+	path := strings.TrimPrefix(r.URL.Path, "/img/emoji/")
+
+	b, err := fs.ReadFile(bundledEmoji, path)
+	if err != nil {
+		log.Errorln(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	contentType := "image/jpeg"
+	cacheTime := utils.GetCacheDurationSecondsForPath(path)
+	writeBytesAsImage(b, contentType, w, cacheTime)
+}

controllers/images.go

@@ -0,0 +1,59 @@
+package controllers
+
+import (
+	"net/http"
+	"path/filepath"
+
+	"github.com/owncast/owncast/config"
+	"github.com/owncast/owncast/utils"
+)
+
+// GetThumbnail will return the thumbnail image as a response.
+func GetThumbnail(w http.ResponseWriter, r *http.Request) {
+	imageFilename := "thumbnail.jpg"
+	imagePath := filepath.Join(config.TempDir, imageFilename)
+
+	var imageBytes []byte
+	var err error
+
+	if utils.DoesFileExists(imagePath) {
+		imageBytes, err = getImage(imagePath)
+	} else {
+		GetLogo(w, r)
+		return
+	}
+
+	if err != nil {
+		GetLogo(w, r)
+		return
+	}
+
+	contentType := "image/jpeg"
+	cacheTime := utils.GetCacheDurationSecondsForPath(imagePath)
+	writeBytesAsImage(imageBytes, contentType, w, cacheTime)
+}
+
+// GetPreview will return the preview gif as a response.
+func GetPreview(w http.ResponseWriter, r *http.Request) {
+	imageFilename := "preview.gif"
+	imagePath := filepath.Join(config.TempDir, imageFilename)
+
+	var imageBytes []byte
+	var err error
+
+	if utils.DoesFileExists(imagePath) {
+		imageBytes, err = getImage(imagePath)
+	} else {
+		GetLogo(w, r)
+		return
+	}
+
+	if err != nil {
+		GetLogo(w, r)
+		return
+	}
+
+	contentType := "image/jpeg"
+	cacheTime := utils.GetCacheDurationSecondsForPath(imagePath)
+	writeBytesAsImage(imageBytes, contentType, w, cacheTime)
+}

controllers/index.go

@@ -1,20 +1,11 @@
 package controllers
 
 import (
-	"fmt"
 	"net/http"
-	"net/url"
 	"path/filepath"
-	"strings"
 
-	log "github.com/sirupsen/logrus"
-
-	"github.com/owncast/owncast/config"
-	"github.com/owncast/owncast/core"
-	"github.com/owncast/owncast/core/data"
 	"github.com/owncast/owncast/models"
 	"github.com/owncast/owncast/router/middleware"
-	"github.com/owncast/owncast/static"
 	"github.com/owncast/owncast/utils"
 )
 
@@ -35,10 +26,6 @@ func IndexHandler(w http.ResponseWriter, r *http.Request) {
 	middleware.EnableCors(w)
 
 	isIndexRequest := r.URL.Path == "/" || filepath.Base(r.URL.Path) == "index.html" || filepath.Base(r.URL.Path) == ""
-	if isIndexRequest {
-		handleScraperMetadataPage(w, r)
-		return
-	}
 
 	if utils.IsUserAgentAPlayer(r.UserAgent()) && isIndexRequest {
 		http.Redirect(w, r, "/hls/stream.m3u8", http.StatusTemporaryRedirect)
@@ -46,10 +33,10 @@ func IndexHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// If the ETags match then return a StatusNotModified
-	if responseCode := middleware.ProcessEtags(w, r); responseCode != 0 {
-		w.WriteHeader(responseCode)
-		return
-	}
+	// if responseCode := middleware.ProcessEtags(w, r); responseCode != 0 {
+	// 	w.WriteHeader(responseCode)
+	// 	return
+	// }
 
 	// If this is a directory listing request then return a 404
 	// info, err := os.Stat(path.Join(config.WebRoot, r.URL.Path))
@@ -65,67 +52,4 @@ func IndexHandler(w http.ResponseWriter, r *http.Request) {
 	middleware.SetHeaders(w)
 
 	serveWeb(w, r)
-
-	// http.ServeFile(w, r, path.Join(config.WebRoot, r.URL.Path))
-}
-
-// Return a basic HTML page with server-rendered metadata from the config
-// to give to Opengraph clients and web scrapers (bots, web crawlers, etc).
-func handleScraperMetadataPage(w http.ResponseWriter, r *http.Request) {
-	tmpl, err := static.GetWebIndexTemplate()
-	if err != nil {
-		log.Errorln(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-
-	scheme := "http"
-
-	if siteURL := data.GetServerURL(); siteURL != "" {
-		if parsed, err := url.Parse(siteURL); err == nil && parsed.Scheme != "" {
-			scheme = parsed.Scheme
-		}
-	}
-
-	fullURL, err := url.Parse(fmt.Sprintf("%s://%s%s", scheme, r.Host, r.URL.Path))
-	if err != nil {
-		log.Errorln(err)
-	}
-	imageURL, err := url.Parse(fmt.Sprintf("%s://%s%s", scheme, r.Host, "/logo/external"))
-	if err != nil {
-		log.Errorln(err)
-	}
-
-	status := core.GetStatus()
-
-	// If the thumbnail does not exist or we're offline then just use the logo image
-	var thumbnailURL string
-	if status.Online && utils.DoesFileExists(filepath.Join(config.WebRoot, "thumbnail.jpg")) {
-		thumbnail, err := url.Parse(fmt.Sprintf("%s://%s%s", scheme, r.Host, "/thumbnail.jpg"))
-		if err != nil {
-			log.Errorln(err)
-			thumbnailURL = imageURL.String()
-		} else {
-			thumbnailURL = thumbnail.String()
-		}
-	} else {
-		thumbnailURL = imageURL.String()
-	}
-
-	tagsString := strings.Join(data.GetServerMetadataTags(), ",")
-	metadata := MetadataPage{
-		Name:          data.GetServerName(),
-		RequestedURL:  fullURL.String(),
-		Image:         imageURL.String(),
-		Summary:       data.GetServerSummary(),
-		Thumbnail:     thumbnailURL,
-		TagsString:    tagsString,
-		Tags:          data.GetServerMetadataTags(),
-		SocialHandles: data.GetSocialHandles(),
-	}
-
-	w.Header().Set("Content-Type", "text/html")
-	if err := tmpl.Execute(w, metadata); err != nil {
-		log.Errorln(err)
-	}
 }

controllers/logo.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/owncast/owncast/config"
 	"github.com/owncast/owncast/core/data"
+	"github.com/owncast/owncast/static"
 	"github.com/owncast/owncast/utils"
 	log "github.com/sirupsen/logrus"
 )
@@ -21,7 +22,7 @@ func GetLogo(w http.ResponseWriter, r *http.Request) {
 		returnDefault(w)
 		return
 	}
-	imagePath := filepath.Join("data", imageFilename)
+	imagePath := filepath.Join(config.DataDirectory, imageFilename)
 	imageBytes, err := getImage(imagePath)
 	if err != nil {
 		returnDefault(w)
@@ -56,7 +57,7 @@ func GetCompatibleLogo(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Otherwise use a fallback logo.png.
-	imagePath := filepath.Join(config.WebRoot, "img", "logo.png")
+	imagePath := filepath.Join(config.DataDirectory, "logo.png")
 	contentType := "image/png"
 	imageBytes, err := getImage(imagePath)
 	if err != nil {
@@ -74,14 +75,9 @@ func GetCompatibleLogo(w http.ResponseWriter, r *http.Request) {
 }
 
 func returnDefault(w http.ResponseWriter) {
-	imagePath := filepath.Join(config.WebRoot, "img", "logo.svg")
-	imageBytes, err := getImage(imagePath)
-	if err != nil {
-		log.Errorln(err)
-		return
-	}
-	cacheTime := utils.GetCacheDurationSecondsForPath(imagePath)
-	writeBytesAsImage(imageBytes, "image/svg+xml", w, cacheTime)
+	imageBytes := static.GetLogo()
+	cacheTime := utils.GetCacheDurationSecondsForPath("logo.png")
+	writeBytesAsImage(imageBytes, "image/png", w, cacheTime)
 }
 
 func writeBytesAsImage(data []byte, contentType string, w http.ResponseWriter, cacheSeconds int) {

controllers/web.go

@@ -16,13 +16,13 @@ import (
 // serveWeb will serve web assets.
 func serveWeb(w http.ResponseWriter, r *http.Request) {
 	// If the ETags match then return a StatusNotModified
-	if responseCode := middleware.ProcessEtags(w, r); responseCode != 0 {
-		w.WriteHeader(responseCode)
-		return
-	}
+	// if responseCode := middleware.ProcessEtags(w, r); responseCode != 0 {
+	// 	w.WriteHeader(responseCode)
+	// 	return
+	// }
 
 	webFiles := static.GetWeb()
-	path := "web/" + strings.TrimPrefix(r.URL.Path, "/")
+	path := strings.TrimPrefix(r.URL.Path, "/")
 
 	// Determine if the requested path is a directory.
 	// If so, append index.html to the request.
@@ -48,7 +48,7 @@ func serveWeb(w http.ResponseWriter, r *http.Request) {
 
 	// Set a cache control max-age header
 	middleware.SetCachingHeaders(w, r)
-	d, err := webFiles.ReadFile(path)
+	d, err := fs.ReadFile(webFiles, path)
 	if err != nil {
 		log.Errorln(err)
 		w.WriteHeader(http.StatusInternalServerError)