Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts. Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation. Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
332 lines
6.3 KiB
Go
332 lines
6.3 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"pageswiki/internal/kunstzeal"
|
|
)
|
|
|
|
var diagramSourceCache = map[string]diagramCacheEntry{}
|
|
var diagramSourceMu sync.Mutex
|
|
|
|
type diagramCacheEntry struct {
|
|
Type string
|
|
Source string
|
|
At time.Time
|
|
Domain string
|
|
Path string
|
|
}
|
|
|
|
func (s *Server) diagramCachePath(kind, hash string) string {
|
|
root := s.diagramRoot
|
|
if root == "" {
|
|
root = "/data/cache/diagram"
|
|
}
|
|
return filepath.Join(root, kind, hash+".svg")
|
|
}
|
|
|
|
func readDiagramCache(path string) ([]byte, error) { return kunstzeal.ReadDiagramCache(path) }
|
|
|
|
func diagramHash(kind, source, format string) string {
|
|
return kunstzeal.DiagramHash(kind, source, format)
|
|
}
|
|
|
|
func allowedDiagramType(kind string) bool { return kunstzeal.AllowedDiagramType(kind) }
|
|
|
|
func normalizeDiagramType(kind string) string { return kunstzeal.NormalizeDiagramType(kind) }
|
|
|
|
func krokiURL() string {
|
|
|
|
v :=
|
|
strings.TrimSpace(
|
|
os.Getenv("KROKI_URL"),
|
|
)
|
|
|
|
if v == "" {
|
|
return "http://kroki:8000"
|
|
}
|
|
|
|
return strings.TrimRight(
|
|
v,
|
|
"/",
|
|
)
|
|
}
|
|
|
|
func (s *Server) renderDiagramsInHTML(
|
|
r *http.Request,
|
|
path string,
|
|
html string,
|
|
) string {
|
|
|
|
re :=
|
|
regexp.MustCompile(`(?s)<pre><code class="language-(mermaid|plantuml|graphviz|dot|d2)">(.+?)</code></pre>`)
|
|
|
|
return re.ReplaceAllStringFunc(
|
|
html,
|
|
func(block string) string {
|
|
|
|
m :=
|
|
re.FindStringSubmatch(
|
|
block,
|
|
)
|
|
|
|
if len(m) != 3 {
|
|
return block
|
|
}
|
|
|
|
diagramType :=
|
|
normalizeDiagramType(
|
|
m[1],
|
|
)
|
|
|
|
source :=
|
|
htmlUnescapeString(
|
|
m[2],
|
|
)
|
|
if len(source) > kunstzeal.DiagramInlineLimit || path == "" {
|
|
return block
|
|
}
|
|
|
|
hash :=
|
|
diagramHash(
|
|
diagramType,
|
|
htmlProjectionVersion+"\x00"+s.domainUUIDForRequest(r)+"\x00"+path+"\x00"+source,
|
|
"svg",
|
|
)
|
|
|
|
diagramSourceMu.Lock()
|
|
if len(diagramSourceCache) >= 128 {
|
|
oldest, key := time.Now(), ""
|
|
for k, v := range diagramSourceCache {
|
|
if v.At.Before(oldest) {
|
|
oldest, key = v.At, k
|
|
}
|
|
}
|
|
delete(diagramSourceCache, key)
|
|
}
|
|
diagramSourceCache[hash] =
|
|
diagramCacheEntry{
|
|
Type: diagramType,
|
|
Source: source,
|
|
At: time.Now(),
|
|
Domain: s.domainUUIDForRequest(r), Path: path,
|
|
}
|
|
diagramSourceMu.Unlock()
|
|
|
|
return `<figure class="diagram diagram-` + diagramType + `">` +
|
|
`<img src="/:/compile/diagram/` + diagramType + `/` + hash + `.svg" loading="lazy" alt="` + diagramType + ` diagram">` +
|
|
`</figure>`
|
|
},
|
|
)
|
|
}
|
|
|
|
func htmlUnescapeString(
|
|
s string,
|
|
) string {
|
|
|
|
r :=
|
|
strings.NewReplacer(
|
|
"<", "<",
|
|
">", ">",
|
|
"&", "&",
|
|
""", `"`,
|
|
"'", "'",
|
|
)
|
|
|
|
return r.Replace(
|
|
s,
|
|
)
|
|
}
|
|
|
|
func (s *Server) handleCompileDiagram(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
) {
|
|
// Apply also to disk-cache hits and direct navigation, not only new renders.
|
|
w.Header().Set("Content-Security-Policy", "sandbox; default-src 'none'; style-src 'unsafe-inline'; img-src data:")
|
|
w.Header().Set("X-Content-Type-Options", "nosniff")
|
|
w.Header().Set("Cache-Control", "private, no-store")
|
|
|
|
if r.Method == http.MethodPost {
|
|
s.handleCompileDiagramPost(
|
|
w,
|
|
r,
|
|
)
|
|
return
|
|
}
|
|
|
|
rest :=
|
|
strings.TrimPrefix(
|
|
r.URL.Path,
|
|
"/:/compile/diagram/",
|
|
)
|
|
|
|
parts :=
|
|
strings.Split(
|
|
rest,
|
|
"/",
|
|
)
|
|
|
|
if len(parts) != 2 {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
diagramType :=
|
|
normalizeDiagramType(
|
|
parts[0],
|
|
)
|
|
|
|
if !allowedDiagramType(diagramType) {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
hashFile :=
|
|
parts[1]
|
|
|
|
if !strings.HasSuffix(hashFile, ".svg") {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
hash :=
|
|
strings.TrimSuffix(
|
|
hashFile,
|
|
".svg",
|
|
)
|
|
|
|
if !regexp.MustCompile(`^[a-f0-9]{64}$`).MatchString(hash) {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
cachePath := s.diagramCachePath(diagramType, hash)
|
|
|
|
diagramSourceMu.Lock()
|
|
entry, ok := diagramSourceCache[hash]
|
|
diagramSourceMu.Unlock()
|
|
if !ok || entry.Type != diagramType || entry.Domain != s.domainUUIDForRequest(r) || time.Since(entry.At) > 30*time.Minute || !s.pathReadFilter(r)(entry.Path) {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
if b, err := readDiagramCache(cachePath); err == nil {
|
|
|
|
w.Header().Set(
|
|
"Content-Type",
|
|
"image/svg+xml; charset=utf-8",
|
|
)
|
|
|
|
_, _ = w.Write(b)
|
|
return
|
|
}
|
|
|
|
s.renderDiagramSVG(
|
|
w,
|
|
r,
|
|
diagramType,
|
|
entry.Source,
|
|
cachePath,
|
|
)
|
|
}
|
|
|
|
func (s *Server) handleCompileDiagramPost(
|
|
w http.ResponseWriter,
|
|
r *http.Request,
|
|
) {
|
|
|
|
rest :=
|
|
strings.TrimPrefix(
|
|
r.URL.Path,
|
|
"/:/compile/diagram/",
|
|
)
|
|
|
|
diagramType :=
|
|
normalizeDiagramType(
|
|
strings.Trim(rest, "/"),
|
|
)
|
|
|
|
if !allowedDiagramType(diagramType) {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
defer r.Body.Close()
|
|
|
|
sourceBytes, err :=
|
|
io.ReadAll(
|
|
io.LimitReader(
|
|
r.Body,
|
|
kunstzeal.DiagramSourceLimit+1,
|
|
),
|
|
)
|
|
|
|
if err != nil || len(sourceBytes) > kunstzeal.DiagramSourceLimit {
|
|
http.Error(w, "diagram source exceeds limit", http.StatusRequestEntityTooLarge)
|
|
return
|
|
}
|
|
|
|
source :=
|
|
string(sourceBytes)
|
|
|
|
hash :=
|
|
diagramHash(
|
|
diagramType,
|
|
source,
|
|
"svg",
|
|
)
|
|
|
|
cachePath := s.diagramCachePath(diagramType, hash)
|
|
|
|
if b, err := readDiagramCache(cachePath); err == nil {
|
|
|
|
w.Header().Set(
|
|
"Content-Type",
|
|
"image/svg+xml; charset=utf-8",
|
|
)
|
|
|
|
_, _ = w.Write(b)
|
|
return
|
|
}
|
|
|
|
s.renderDiagramSVG(
|
|
w,
|
|
r,
|
|
diagramType,
|
|
source,
|
|
cachePath,
|
|
)
|
|
}
|
|
|
|
// The configured service may be private (Compose), but it may not redirect
|
|
// source content to another destination. Authorization is checked before this.
|
|
func diagramHTTPClient() *http.Client {
|
|
return &http.Client{Timeout: kunstzeal.DiagramTimeout, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
|
|
}
|
|
|
|
func (s *Server) renderDiagramSVG(w http.ResponseWriter, r *http.Request, diagramType, source, cachePath string) {
|
|
provider := kunstzeal.Kroki{Endpoint: krokiURL(), Client: diagramHTTPClient()}
|
|
b, err := provider.Render(r.Context(), diagramType, source)
|
|
if err != nil {
|
|
status := http.StatusBadGateway
|
|
if errors.Is(err, kunstzeal.ErrProviderConfig) {
|
|
status = http.StatusInternalServerError
|
|
}
|
|
http.Error(w, err.Error(), status)
|
|
return
|
|
}
|
|
// Cache failure must not discard a successfully generated projection.
|
|
_ = kunstzeal.WriteDiagramCache(cachePath, b)
|
|
w.Header().Set("Content-Type", "image/svg+xml; charset=utf-8")
|
|
w.Header().Set("Content-Security-Policy", "sandbox; default-src 'none'; style-src 'unsafe-inline'; img-src data:")
|
|
_, _ = w.Write(b)
|
|
}
|