477 lines
12 KiB
Go
477 lines
12 KiB
Go
package server
|
|
|
|
import (
|
|
"fmt"
|
|
"io/fs"
|
|
"net/http"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"fes/src/config"
|
|
"github.com/fatih/color"
|
|
"github.com/gomarkdown/markdown"
|
|
"github.com/gomarkdown/markdown/html"
|
|
"github.com/gomarkdown/markdown/parser"
|
|
"github.com/pelletier/go-toml/v2"
|
|
lua "github.com/yuin/gopher-lua"
|
|
"html/template"
|
|
)
|
|
|
|
type reqData struct {
|
|
path string
|
|
params map[string]string
|
|
}
|
|
|
|
func handleDir(entries []os.DirEntry, dir string, routes map[string]string, base string, isStatic bool) error {
|
|
for _, entry := range entries {
|
|
path := filepath.Join(dir, entry.Name())
|
|
if entry.IsDir() {
|
|
nextBase := joinBase(base, entry.Name())
|
|
subEntries, err := os.ReadDir(path)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to read directory %s: %w", path, err)
|
|
}
|
|
if err := handleDir(subEntries, path, routes, nextBase, isStatic); err != nil {
|
|
return err
|
|
}
|
|
continue
|
|
}
|
|
route := joinBase(base, entry.Name())
|
|
if !isStatic && strings.HasSuffix(entry.Name(), ".lua") {
|
|
name := strings.TrimSuffix(entry.Name(), ".lua")
|
|
if name == "index" {
|
|
routes[basePath(base)] = path
|
|
routes[route] = path
|
|
continue
|
|
}
|
|
route = joinBase(base, name)
|
|
}
|
|
routes[route] = path
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func joinBase(base, name string) string {
|
|
if base == "" {
|
|
return "/" + name
|
|
}
|
|
return base + "/" + name
|
|
}
|
|
|
|
func basePath(base string) string {
|
|
if base == "" {
|
|
return "/"
|
|
}
|
|
return base
|
|
}
|
|
|
|
func fixMalformedToml(content string) string {
|
|
re := regexp.MustCompile(`(?m)^(\s*\w+\s*=\s*)$`)
|
|
return re.ReplaceAllStringFunc(content, func(match string) string {
|
|
parts := strings.Split(strings.TrimSpace(match), "=")
|
|
if len(parts) == 2 && strings.TrimSpace(parts[1]) == "" {
|
|
key := strings.TrimSpace(parts[0])
|
|
return key + " = \"\""
|
|
}
|
|
return match
|
|
})
|
|
}
|
|
|
|
func markdownToHTML(mdText string) string {
|
|
extensions := parser.CommonExtensions | parser.AutoHeadingIDs | parser.NoEmptyLineBeforeBlock
|
|
p := parser.NewWithExtensions(extensions)
|
|
doc := p.Parse([]byte(mdText))
|
|
htmlFlags := html.CommonFlags | html.HrefTargetBlank
|
|
opts := html.RendererOptions{Flags: htmlFlags}
|
|
renderer := html.NewRenderer(opts)
|
|
return string(markdown.Render(doc, renderer))
|
|
}
|
|
|
|
func loadIncludeModules(L *lua.LState, includeDir string) *lua.LTable {
|
|
app := L.NewTable()
|
|
ents, err := os.ReadDir(includeDir)
|
|
if err != nil {
|
|
return app
|
|
}
|
|
for _, e := range ents {
|
|
if e.IsDir() || !strings.HasSuffix(e.Name(), ".lua") {
|
|
continue
|
|
}
|
|
base := strings.TrimSuffix(e.Name(), ".lua")
|
|
path := filepath.Join(includeDir, e.Name())
|
|
if _, err := os.Stat(path); err != nil {
|
|
tbl := L.NewTable()
|
|
tbl.RawSetString("error", lua.LString(fmt.Sprintf("file not found: %s", path)))
|
|
app.RawSetString(base, tbl)
|
|
continue
|
|
}
|
|
if err := L.DoFile(path); err != nil {
|
|
tbl := L.NewTable()
|
|
tbl.RawSetString("error", lua.LString(err.Error()))
|
|
app.RawSetString(base, tbl)
|
|
continue
|
|
}
|
|
val := L.Get(-1)
|
|
L.Pop(1)
|
|
tbl, ok := val.(*lua.LTable)
|
|
if !ok || tbl == nil {
|
|
tbl = L.NewTable()
|
|
}
|
|
app.RawSetString(base, tbl)
|
|
}
|
|
return app
|
|
}
|
|
|
|
func loadLua(luaDir string, entry string, cfg *config.MyConfig, requestData reqData) (string, error) {
|
|
L := lua.NewState()
|
|
defer L.Close()
|
|
|
|
coreFiles, err := fs.ReadDir(config.Core, "core")
|
|
if err == nil {
|
|
for _, de := range coreFiles {
|
|
if de.IsDir() || !strings.HasSuffix(de.Name(), ".lua") {
|
|
continue
|
|
}
|
|
path := filepath.Join("core", de.Name())
|
|
fileData, err := config.Core.ReadFile(path)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
L.DoString(string(fileData))
|
|
}
|
|
}
|
|
|
|
preloadLuaModule := func(name, path string) {
|
|
L.PreloadModule(name, func(L *lua.LState) int {
|
|
fileData, err := config.Core.ReadFile(path)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if err := L.DoString(string(fileData)); err != nil {
|
|
panic(err)
|
|
}
|
|
L.Push(L.Get(-1))
|
|
return 1
|
|
})
|
|
}
|
|
|
|
preloadLuaModule("core.std", "core/std.lua")
|
|
preloadLuaModule("core.symbol", "core/symbol.lua")
|
|
preloadLuaModule("core.util", "core/util.lua")
|
|
|
|
L.PreloadModule("fes", func(L *lua.LState) int {
|
|
mod := L.NewTable()
|
|
coreModules := []string{}
|
|
if ents, err := fs.ReadDir(config.Core, "core"); err == nil {
|
|
for _, e := range ents {
|
|
if e.IsDir() || !strings.HasSuffix(e.Name(), ".lua") {
|
|
continue
|
|
}
|
|
coreModules = append(coreModules, strings.TrimSuffix(e.Name(), ".lua"))
|
|
}
|
|
}
|
|
for _, modName := range coreModules {
|
|
path := filepath.Join("core", modName+".lua")
|
|
fileData, err := config.Core.ReadFile(path)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if err := L.DoString(string(fileData)); err != nil {
|
|
continue
|
|
}
|
|
val := L.Get(-1)
|
|
L.Pop(1)
|
|
tbl, ok := val.(*lua.LTable)
|
|
if !ok || tbl == nil {
|
|
tbl = L.NewTable()
|
|
}
|
|
if modName == "builtin" {
|
|
tbl.ForEach(func(k, v lua.LValue) { mod.RawSet(k, v) })
|
|
} else {
|
|
mod.RawSetString(modName, tbl)
|
|
}
|
|
}
|
|
|
|
mod.RawSetString("app", loadIncludeModules(L, filepath.Join(".", "include")))
|
|
|
|
if cfg != nil {
|
|
site := L.NewTable()
|
|
site.RawSetString("version", lua.LString(cfg.App.Version))
|
|
site.RawSetString("name", lua.LString(cfg.App.Name))
|
|
authors := L.NewTable()
|
|
for i, a := range cfg.App.Authors {
|
|
authors.RawSetInt(i+1, lua.LString(a))
|
|
}
|
|
site.RawSetString("authors", authors)
|
|
mod.RawSetString("site", site)
|
|
}
|
|
|
|
bus := L.NewTable()
|
|
bus.RawSetString("url", lua.LString(requestData.path))
|
|
params := L.NewTable()
|
|
for k, v := range requestData.params {
|
|
params.RawSetString(k, lua.LString(v))
|
|
}
|
|
bus.RawSetString("params", params)
|
|
mod.RawSetString("bus", bus)
|
|
|
|
mod.RawSetString("markdown_to_html", L.NewFunction(func(L *lua.LState) int {
|
|
L.Push(lua.LString(markdownToHTML(L.ToString(1))))
|
|
return 1
|
|
}))
|
|
|
|
L.Push(mod)
|
|
return 1
|
|
})
|
|
|
|
if err := L.DoFile(entry); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
if L.GetTop() == 0 {
|
|
return "", nil
|
|
}
|
|
|
|
L.SetGlobal("__fes_result", L.Get(-1))
|
|
if err := L.DoString("return tostring(__fes_result)"); err != nil {
|
|
L.GetGlobal("__fes_result")
|
|
if s := L.ToString(-1); s != "" {
|
|
return s, nil
|
|
}
|
|
return "", nil
|
|
}
|
|
|
|
if s := L.ToString(-1); s != "" {
|
|
return s, nil
|
|
}
|
|
return "", nil
|
|
}
|
|
|
|
func generateArchiveIndex(fsPath string, urlPath string) (string, error) {
|
|
info, err := os.Stat(fsPath)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if !info.IsDir() {
|
|
return "", fmt.Errorf("not a directory")
|
|
}
|
|
ents, err := os.ReadDir(fsPath)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
type entryInfo struct {
|
|
name string
|
|
isDir bool
|
|
href string
|
|
size int64
|
|
mod time.Time
|
|
}
|
|
var list []entryInfo
|
|
for _, e := range ents {
|
|
n := e.Name()
|
|
full := filepath.Join(fsPath, n)
|
|
st, err := os.Stat(full)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
isd := st.IsDir()
|
|
displayName := n
|
|
if isd {
|
|
displayName = n + "/"
|
|
}
|
|
href := path.Join(urlPath, n)
|
|
if isd && !strings.HasSuffix(href, "/") {
|
|
href = href + "/"
|
|
}
|
|
size := int64(-1)
|
|
if !isd {
|
|
size = st.Size()
|
|
}
|
|
list = append(list, entryInfo{name: displayName, isDir: isd, href: href, size: size, mod: st.ModTime()})
|
|
}
|
|
sort.Slice(list, func(i, j int) bool {
|
|
if list[i].isDir != list[j].isDir {
|
|
return list[i].isDir
|
|
}
|
|
return strings.ToLower(list[i].name) < strings.ToLower(list[j].name)
|
|
})
|
|
|
|
urlPath = basePath(strings.TrimPrefix(urlPath, "/archive"))
|
|
|
|
var b strings.Builder
|
|
b.WriteString("<html>\n<head><title>Index of ")
|
|
b.WriteString(template.HTMLEscapeString(urlPath))
|
|
b.WriteString("</title></head>\n<body>\n<h1>Index of ")
|
|
b.WriteString(template.HTMLEscapeString(urlPath))
|
|
b.WriteString("</h1><hr><pre>")
|
|
if urlPath != "/archive" && urlPath != "/archive/" {
|
|
up := path.Dir(urlPath)
|
|
if up == "." {
|
|
up = "/archive"
|
|
}
|
|
if !strings.HasSuffix(up, "/") {
|
|
up = up + "/"
|
|
}
|
|
b.WriteString(`<a href="` + template.HTMLEscapeString(up) + `">../</a>` + "\n")
|
|
} else {
|
|
b.WriteString(`<a href="../">../</a>` + "\n")
|
|
}
|
|
nameCol := 50
|
|
for _, ei := range list {
|
|
escapedName := template.HTMLEscapeString(ei.name)
|
|
dateStr := ei.mod.Local().Format("02-Jan-2006 15:04")
|
|
var sizeStr string
|
|
if ei.isDir {
|
|
sizeStr = "-"
|
|
} else {
|
|
sizeStr = fmt.Sprintf("%d", ei.size)
|
|
}
|
|
spaces := 1
|
|
if len(escapedName) < nameCol {
|
|
spaces = nameCol - len(escapedName)
|
|
}
|
|
line := `<a href="` + template.HTMLEscapeString(ei.href) + `">` + escapedName + `</a>` + strings.Repeat(" ", spaces) + dateStr + strings.Repeat(" ", 19-len(sizeStr)) + sizeStr + "\n"
|
|
b.WriteString(line)
|
|
}
|
|
b.WriteString("</pre><hr></body>\n</html>")
|
|
return b.String(), nil
|
|
}
|
|
|
|
func Start(dir string) error {
|
|
if err := os.Chdir(dir); err != nil {
|
|
return fmt.Errorf("failed to change directory to %s: %w", dir, err)
|
|
}
|
|
dir = "."
|
|
|
|
tomlDocument, err := os.ReadFile("Fes.toml")
|
|
if err != nil {
|
|
return fmt.Errorf("failed to read Fes.toml: %w", err)
|
|
}
|
|
docStr := fixMalformedToml(string(tomlDocument))
|
|
var cfg config.MyConfig
|
|
if err := toml.Unmarshal([]byte(docStr), &cfg); err != nil {
|
|
fmt.Printf("Warning: failed to parse Fes.toml: %v\n", err)
|
|
cfg.App.Authors = []string{"unknown"}
|
|
cfg.App.Name = "unknown"
|
|
cfg.App.Version = "unknown"
|
|
}
|
|
|
|
notFoundData := `
|
|
<html>
|
|
<head><title>404 Not Found</title></head>
|
|
<body>
|
|
<center><h1>404 Not Found</h1></center>
|
|
<hr><center>fes</center>
|
|
</body>
|
|
</html>
|
|
`
|
|
if _, err := os.Stat(filepath.Join("www", "404.lua")); err == nil {
|
|
if nf, err := loadLua(dir, "www/404.lua", &cfg, reqData{}); err == nil {
|
|
notFoundData = nf
|
|
}
|
|
} else if _, err := os.Stat("www/404.html"); err == nil {
|
|
if buf, err := os.ReadFile("www/404.html"); err == nil {
|
|
notFoundData = string(buf)
|
|
}
|
|
}
|
|
|
|
routes := make(map[string]string)
|
|
if entries, err := os.ReadDir("www"); err == nil {
|
|
if err := handleDir(entries, "www", routes, "", false); err != nil {
|
|
fmt.Printf("Warning: failed to handle www directory: %v\n", err)
|
|
}
|
|
}
|
|
|
|
if entries, err := os.ReadDir("static"); err == nil {
|
|
if err := handleDir(entries, "static", routes, "/static", true); err != nil {
|
|
fmt.Printf("Warning: failed to handle static directory: %v\n", err)
|
|
}
|
|
}
|
|
|
|
if entries, err := os.ReadDir("archive"); err == nil {
|
|
if err := handleDir(entries, "archive", routes, "/archive", true); err != nil {
|
|
fmt.Printf("Warning: failed to handle archive directory: %v\n", err)
|
|
}
|
|
}
|
|
|
|
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
path := r.URL.Path
|
|
lp, ok := routes[path]
|
|
|
|
if !ok && strings.HasPrefix(path, "/archive") {
|
|
fsPath := "." + path
|
|
info, err := os.Stat(fsPath)
|
|
if err == nil && info.IsDir() {
|
|
if htmlStr, err := generateArchiveIndex(fsPath, path); err == nil {
|
|
w.Write([]byte(htmlStr))
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
if !ok {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte(notFoundData))
|
|
fmt.Printf("> %s ", path)
|
|
color.Yellow("not found")
|
|
return
|
|
}
|
|
|
|
params := make(map[string]string)
|
|
for k, val := range r.URL.Query() {
|
|
if len(val) > 0 {
|
|
params[k] = val[0]
|
|
}
|
|
}
|
|
|
|
req := reqData{
|
|
path: path,
|
|
params: params,
|
|
}
|
|
|
|
fmt.Printf("> %s ", filepath.Base(lp))
|
|
|
|
var data []byte
|
|
var err error
|
|
|
|
if strings.HasSuffix(lp, ".lua") {
|
|
var b string
|
|
b, err = loadLua(dir, lp, &cfg, req)
|
|
data = []byte(b)
|
|
} else {
|
|
data, err = os.ReadFile(lp)
|
|
}
|
|
|
|
if err != nil {
|
|
http.Error(w, fmt.Sprintf("Error loading page: %v", err), http.StatusInternalServerError)
|
|
color.Red("bad")
|
|
return
|
|
}
|
|
|
|
color.Green("ok")
|
|
w.Write(data)
|
|
})
|
|
|
|
addrHTTPS := fmt.Sprintf(":%d", *config.HTTPSPort)
|
|
addrHTTP := fmt.Sprintf(":%d", *config.Port)
|
|
|
|
go func() {
|
|
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
target := "https://" + r.Host + r.RequestURI
|
|
http.Redirect(w, r, target, http.StatusMovedPermanently)
|
|
})
|
|
fmt.Printf("Redirecting HTTP to HTTPS on port %d\n", *config.Port)
|
|
if err := http.ListenAndServe(addrHTTP, nil); err != nil {
|
|
fmt.Printf("HTTP redirect server error: %v\n", err)
|
|
}
|
|
}()
|
|
|
|
fmt.Printf("HTTPS server is running on https://localhost:%d\n", *config.HTTPSPort)
|
|
return http.ListenAndServeTLS(addrHTTPS, "cert.pem", "key.pem", handler)
|
|
}
|