Use bundled images instead of old webroot files

activitypub/outbox/outbox.go

@@ -77,8 +77,8 @@ func SendLive() error {
 	if err == nil {
 		var imageToAttach string
 		var mediaType string
-		previewGif := filepath.Join(config.WebRoot, "preview.gif")
-		thumbnailJpg := filepath.Join(config.WebRoot, "thumbnail.jpg")
+		previewGif := filepath.Join(config.TempDir, "preview.gif")
+		thumbnailJpg := filepath.Join(config.TempDir, "thumbnail.jpg")
 		uniquenessString := shortid.MustGenerate()
 		if utils.DoesFileExists(previewGif) {
 			imageToAttach = "preview.gif"

config/constants.go

@@ -5,8 +5,6 @@ import "path/filepath"
 const (
 	// StaticVersionNumber is the version of Owncast that is used when it's not overwritten via build-time settings.
 	StaticVersionNumber = "0.0.12" // Shown when you build from develop
-	// WebRoot is the web server root directory.
-	WebRoot = "webroot"
 	// FfmpegSuggestedVersion is the version of ffmpeg we suggest.
 	FfmpegSuggestedVersion = "v4.1.5" // Requires the v
 	// DataDirectory is the directory we save data to.

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)

core/core.go

@@ -112,12 +112,13 @@ func transitionToOfflineVideoStreamContent() {
 
 	// Copy the logo to be the thumbnail
 	logo := data.GetLogoPath()
-	if err = utils.Copy(filepath.Join("data", logo), "webroot/thumbnail.jpg"); err != nil {
+	dst := filepath.Join(config.TempDir, "thumbnail.jpg")
+	if err = utils.Copy(filepath.Join("data", logo), dst); err != nil {
 		log.Warnln(err)
 	}
 
 	// Delete the preview Gif
-	_ = os.Remove(path.Join(config.WebRoot, "preview.gif"))
+	_ = os.Remove(path.Join(config.DataDirectory, "preview.gif"))
 }
 
 func resetDirectories() {
@@ -129,7 +130,7 @@ func resetDirectories() {
 	// Remove the previous thumbnail
 	logo := data.GetLogoPath()
 	if utils.DoesFileExists(logo) {
-		err := utils.Copy(path.Join("data", logo), filepath.Join(config.WebRoot, "thumbnail.jpg"))
+		err := utils.Copy(path.Join("data", logo), filepath.Join(config.DataDirectory, "thumbnail.jpg"))
 		if err != nil {
 			log.Warnln(err)
 		}

core/data/config.go

@@ -2,6 +2,7 @@ package data
 
 import (
 	"errors"
+	"os"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -9,6 +10,7 @@ import (
 
 	"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"
 )
@@ -583,12 +585,10 @@ func VerifySettings() error {
 
 	logoPath := GetLogoPath()
 	if !utils.DoesFileExists(filepath.Join(config.DataDirectory, logoPath)) {
-		defaultLogo := filepath.Join(config.WebRoot, "img/logo.svg")
 		log.Traceln(logoPath, "not found in the data directory. copying a default logo.")
-		if err := utils.Copy(defaultLogo, filepath.Join(config.DataDirectory, "logo.svg")); err != nil {
-			log.Errorln("error copying default logo: ", err)
-		}
-		if err := SetLogoPath("logo.svg"); err != nil {
+		logo := static.GetLogo()
+		os.WriteFile(filepath.Join(config.DataDirectory, "logo.png"), logo, 0o600)
+		if err := SetLogoPath("logo.png"); err != nil {
 			log.Errorln("unable to set default logo to logo.svg", err)
 		}
 	}

core/transcoder/thumbnailGenerator.go

@@ -49,8 +49,8 @@ func StartThumbnailGenerator(chunkPath string, variantIndex int) {
 
 func fireThumbnailGenerator(segmentPath string, variantIndex int) error {
 	// JPG takes less time to encode than PNG
-	outputFile := path.Join(config.WebRoot, "thumbnail.jpg")
-	previewGifFile := path.Join(config.WebRoot, "preview.gif")
+	outputFile := path.Join(config.TempDir, "thumbnail.jpg")
+	previewGifFile := path.Join(config.TempDir, "preview.gif")
 
 	framePath := path.Join(segmentPath, strconv.Itoa(variantIndex))
 	files, err := os.ReadDir(framePath)
@@ -87,7 +87,7 @@ func fireThumbnailGenerator(segmentPath string, variantIndex int) error {
 
 	mostRecentFile := path.Join(framePath, names[0])
 	ffmpegPath := utils.ValidatedFfmpegPath(data.GetFfMpegPath())
-	outputFileTemp := path.Join(config.WebRoot, "tempthumbnail.jpg")
+	outputFileTemp := path.Join(config.TempDir, "tempthumbnail.jpg")
 
 	thumbnailCmdFlags := []string{
 		ffmpegPath,
@@ -117,7 +117,7 @@ func fireThumbnailGenerator(segmentPath string, variantIndex int) error {
 
 func makeAnimatedGifPreview(sourceFile string, outputFile string) {
 	ffmpegPath := utils.ValidatedFfmpegPath(data.GetFfMpegPath())
-	outputFileTemp := path.Join(config.WebRoot, "temppreview.gif")
+	outputFileTemp := path.Join(config.TempDir, "temppreview.gif")
 
 	// Filter is pulled from https://engineering.giphy.com/how-to-make-gifs-with-ffmpeg/
 	animatedGifFlags := []string{

router/middleware/caching.go

@@ -2,12 +2,8 @@ package middleware
 
 import (
 	"net/http"
-	"os"
-	"path/filepath"
 	"strconv"
 
-	"github.com/amalfra/etag"
-	"github.com/owncast/owncast/config"
 	"github.com/owncast/owncast/utils"
 )
 
@@ -22,25 +18,6 @@ func setCacheSeconds(seconds int, w http.ResponseWriter) {
 	w.Header().Set("Cache-Control", "public, max-age="+secondsStr)
 }
 
-// ProcessEtags gets and sets ETags for caching purposes.
-func ProcessEtags(w http.ResponseWriter, r *http.Request) int {
-	info, err := os.Stat(filepath.Join(config.WebRoot, r.URL.Path))
-	if err != nil {
-		return 0
-	}
-
-	localContentEtag := etag.Generate(info.ModTime().String(), true)
-	if remoteEtagHeader := r.Header.Get("If-None-Match"); remoteEtagHeader != "" {
-		if remoteEtagHeader == localContentEtag {
-			return http.StatusNotModified
-		}
-	}
-
-	w.Header().Set("Etag", localContentEtag)
-
-	return 0
-}
-
 // SetCachingHeaders will set the cache control header of a response.
 func SetCachingHeaders(w http.ResponseWriter, r *http.Request) {
 	setCacheSeconds(utils.GetCacheDurationSecondsForPath(r.URL.Path), w)

router/router.go

@@ -25,15 +25,26 @@ import (
 
 // Start starts the router for the http, ws, and rtmp.
 func Start() error {
-	// static files
+	// The admin web app.
 	http.HandleFunc("/admin", middleware.RequireAdminAuth(controllers.IndexHandler))
+
+	// The primary web app.
 	http.HandleFunc("/", controllers.IndexHandler)
 
+	// Return a single emoji image.
+	http.HandleFunc("/img/emoji/", middleware.RequireAdminAuth(controllers.GetCustomEmojiImage))
+
+	// return the logo
+	http.HandleFunc("/logo", controllers.GetLogo)
+
+	// return a logo that's compatible with external social networks
+	http.HandleFunc("/logo/external", controllers.GetCompatibleLogo)
+
 	// status of the system
 	http.HandleFunc("/api/status", controllers.GetStatus)
 
 	// custom emoji supported in the chat
-	http.HandleFunc("/api/emoji", controllers.GetCustomEmoji)
+	http.HandleFunc("/api/emoji", controllers.GetCustomEmojiList)
 
 	// chat rest api
 	http.HandleFunc("/api/chat", middleware.RequireUserAccessToken(controllers.GetChatMessages))
@@ -59,12 +70,6 @@ func Start() error {
 	// list of all social platforms
 	http.HandleFunc("/api/socialplatforms", controllers.GetAllSocialPlatforms)
 
-	// return the logo
-	http.HandleFunc("/logo", controllers.GetLogo)
-
-	// return a logo that's compatible with external social networks
-	http.HandleFunc("/logo/external", controllers.GetCompatibleLogo)
-
 	// return the list of video variants available
 	http.HandleFunc("/api/video/variants", controllers.GetVideoStreamOutputVariants)