Files
Anya Tokugawa d5d21b7841
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s
Refactor architecture into eight components and consolidate reliability work
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.
2026-11-01 15:23:31 +09:00

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(
"&lt;", "<",
"&gt;", ">",
"&amp;", "&",
"&#34;", `"`,
"&#39;", "'",
)
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)
}