Files
pages/internal/server/server.go
T
Anya Tokugawa 02fb77f72b
Build and publish container images / images (push) Successful in 9m2s
Release container images / release (push) Successful in 21s
feat(slides): add sandboxed Reveal.js viewer and editor preview
2026-11-08 22:10:52 +09:00

386 lines
8.8 KiB
Go

package server
import (
"database/sql"
"errors"
"fmt"
"html/template"
"log"
"net/http"
"strings"
"sync"
"sync/atomic"
"time"
mw "pageswiki/internal/server/middleware"
routespkg "pageswiki/internal/server/routes"
"pageswiki/internal/calendar"
"pageswiki/internal/dregarnuhr"
"pageswiki/internal/store"
)
type Server struct {
geckoOnce sync.Once
gecko *geckoProxy
calendarOnce sync.Once
calendarRepo *calendar.Repository
calendarErr error
navigationCache navigationDataCache
mux *http.ServeMux
templates *template.Template
store *store.Store
previewSlots chan struct{}
smtpSlots chan struct{}
ldapSlots chan struct{}
ldapDial ldapDialFunc
previewRoot string
diagramRoot string
importRoot string
schedulerWake chan struct{}
foregroundRequests atomic.Int64
schedulerRunning atomic.Int64
schedulerOnce sync.Once
schedulerRunner *dregarnuhr.Runner
eventHandlersOnce sync.Once
eventHandlers *dregarnuhr.Registry
}
func New(
st *store.Store,
) *Server {
s := &Server{
mux: http.NewServeMux(),
store: st,
previewSlots: make(chan struct{}, 1),
smtpSlots: make(chan struct{}, 2),
ldapSlots: make(chan struct{}, 4),
ldapDial: dialLDAPDirectory,
schedulerWake: make(chan struct{}, 1),
}
if !st.ReadOnly {
s.initializePreviewScheduler()
s.initializeImportRoot()
}
s.mustLoadTemplates()
s.registerStaticRoutes()
s.mux.HandleFunc("/_/api/v1/editor/state", s.handleEditorState)
s.mux.HandleFunc("/_/api/v1/editor/convert", s.handleEditorConvert)
s.mux.HandleFunc(
"/o/e/",
s.handleObjectEdit,
)
s.mux.HandleFunc(
"/o/r/",
s.handleObjectRevisionHistory,
)
s.mux.HandleFunc(
"/o/",
func(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.URL.Path, "/o/uuid:") {
s.handleObjectView(w, r)
return
}
s.handleObjectRoute(w, r)
},
)
s.mux.HandleFunc(
"/r/history/",
s.handleRevisionBrowser,
)
s.mux.HandleFunc(
"/r/view/",
s.handleRevisionView,
)
s.mux.HandleFunc(
"/r/diff/",
s.handleRevisionDiff,
)
s.registerRoutes()
if !st.ReadOnly && !st.BackgroundJobsDisabled {
s.startGCWorker()
s.startEventScheduler()
}
return s
}
func (s *Server) registerStaticRoutes() {
s.mux.HandleFunc(socialImagePath, handleSocialImage)
staticFS := http.FileServer(
http.Dir("./static"),
)
s.mux.Handle(
"/static/",
http.StripPrefix(
"/static/",
staticFS,
),
)
themeFS := http.FileServer(
http.Dir("/data/themes"),
)
s.mux.Handle(
"/-/theme/",
http.StripPrefix(
"/-/theme/",
themeFS,
),
)
}
func (s *Server) mustLoadTemplates() {
funcs := template.FuncMap{
"cspNonce": func() string { return "" },
"parentPath": parentPath,
"T": s.T,
"sub": func(a, b int) int {
return a - b
},
"add": func(a, b int) int {
return a + b
},
"mulFloat": func(a, b float64) float64 {
return a * b
},
"until": func(n int) []int {
out := make([]int, n)
for i := 0; i < n; i++ {
out[i] = i
}
return out
},
"formatBytes": func(n int) string {
if n < 1024 {
return fmt.Sprintf("%d B", n)
}
if n < 1024*1024 {
return fmt.Sprintf("%.1f KiB", float64(n)/1024.0)
}
return fmt.Sprintf("%.1f MiB", float64(n)/(1024.0*1024.0))
},
"formatUnix": func(ts int64) string {
if ts <= 0 {
return "-"
}
return time.
Unix(ts, 0).
In(s.getLocation()).
Format("2006-01-02 15:04")
},
"formatUnixMS": func(ts int64) string {
if ts <= 0 {
return "-"
}
return time.UnixMilli(ts).In(s.getLocation()).Format("2006-01-02 15:04")
},
}
tmpl := template.New("").Funcs(funcs)
parsed, err := parseTrustedTemplates(tmpl)
if err != nil {
panic(err)
}
s.templates = parsed
}
func (s *Server) registerRoutes() {
s.registerCalendarRoutes()
s.registerTaskRoutes()
s.mux.HandleFunc("/_/auth/", s.handleAuth)
s.mux.HandleFunc("/_/auth/profile", s.handleProfile)
s.mux.HandleFunc("/_/obj/", s.handleImmutableObject)
s.mux.HandleFunc("/v/json/", s.handleJSONStructure)
s.mux.HandleFunc("/_/api/v1/assets", s.handleAssetsAPI)
s.mux.HandleFunc("/_/api/v1/path-picker", s.handlePathPickerAPI)
s.mux.HandleFunc("/_/api/v1/browser/navigation", s.handleBrowserNavigationAPI)
s.mux.HandleFunc("/u/", s.handleUserProfile)
s.mux.HandleFunc("/g", s.handleGroups)
s.mux.HandleFunc("/g/", s.handleGroups)
s.mux.HandleFunc("/_/api/v1/city/", s.handleCityAPI)
s.mux.HandleFunc("/v/import", s.handleImport)
s.mux.HandleFunc("/v/import/", s.handleImport)
s.mux.HandleFunc("/_/api/v1/import/", s.handleImportAPI)
s.mux.HandleFunc("/-/sys/config/auth", s.handleAuthAdmin)
s.mux.Handle(adapterGatewayPrefix+"/", newAdapterGatewayProxy())
routespkg.RegisterUIRoutes(
s.mux,
routespkg.UIHandlers{
Home: s.handleHome,
NewPage: s.handleNewPage,
SemanticEditor: s.handleEditorRoute,
SemanticPage: s.handleSemanticRoute,
RawView: s.handleRawView,
TextWindow: s.handleTextWindow,
LinkManager: s.handleLinkManager,
Health: s.handleHealth,
Tree: s.handleTree,
Browser: s.handleBrowser,
Preview: s.handlePreview,
PlainView: s.handlePlainView,
MarkdownView: s.handleMarkdownView,
Slides: s.handleSlides,
CompileMarkdown: s.handleCompileMarkdown,
CompileDiagram: s.handleCompileDiagram,
Config: s.handleConfig,
AdapterConfig: s.handleAdapterPluginConfig,
VimConfig: s.handleVimSettings,
SystemExtensions: s.handleSystemExtensions,
Periodical: s.handlePeriodical,
Upload: s.handleUpload,
Children: s.handleChildrenProjection,
Bookmarks: s.handleBookmarkChildren,
PreviewCache: s.handlePreviewCache,
Search: s.handleSearch,
Archive: s.handleArchiveEntry,
EmailHTML: s.handleEmailHTML,
PDFPage: s.handlePDFPage,
OpenWith: s.handleOpenWith,
City: s.handleCityMap,
Print: s.handlePrint,
Notifications: s.handleNotificationsPage,
},
)
routespkg.RegisterAPIRoutes(
s.mux,
routespkg.APIHandlers{
CreateObject: s.handleCreateObjectAPI,
ListObjects: s.handleListObjectsAPI,
DeleteObject: s.handleDeleteObjectAPI,
SaveRevision: s.handleSaveRevisionAPI,
ListRevisions: s.handleRevisionListAPI,
RestoreRevision: s.handleRestoreRevisionAPI,
RenderMarkdown: s.handleMarkdownRenderAPI,
AddTag: s.handleTagAddAPI,
BindPath: s.handleBindPathAPI,
RenamePath: s.handleRenamePath,
RenamePreview: s.handleRenamePreview,
RemovePath: s.handleRemovePathAPI,
CopyPath: s.handleCopyPathAPI,
ZombieList: s.handleZombieListAPI,
ZombiePurge: s.handleZombiePurgeAPI,
FederationEnroll: s.handleFederationEnrollAPI,
Event: s.handleEventAPI,
Queue: s.handleQueueAPI,
Adapter: s.handleAdapterAPI,
AdapterSession: s.handleAdapterSessionAPI,
Notifications: s.handleNotificationsAPI,
Publication: s.handlePublicationApprovalAPI,
SearchSuggest: s.handleSearchSuggestAPI,
},
)
}
func (s *Server) handler() http.Handler {
var h http.Handler = s.mux
h = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/_/api/v1/federation/enroll" ||
strings.HasPrefix(r.URL.Path, "/_/api/v1/adapter/session/") ||
strings.HasPrefix(r.URL.Path, adapterGatewayPrefix+"/") ||
r.URL.Path == "/health" {
s.mux.ServeHTTP(w, r)
return
}
domain, err := s.domainForRequestWithError(r)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
http.NotFound(w, r)
return
}
logDomainLookupError(r, err)
http.Error(
w,
"domain lookup temporarily unavailable",
http.StatusServiceUnavailable,
)
return
}
if domain == nil {
http.NotFound(w, r)
return
}
if domain.Placement == "remote" {
http.Error(
w,
"remote domain is not served by this instance",
http.StatusMisdirectedRequest,
)
return
}
s.mux.ServeHTTP(w, r)
})
domainHandler := h
h = s.withAuthorization(h)
domainHandler = h
h = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
background := r.URL.Query().Get("preview") == "1" ||
strings.HasPrefix(r.URL.Path, "/v/preview-cache/") || r.URL.Path == feedsAPI+"browser/wisp/"
if !background {
s.foregroundRequests.Add(1)
defer s.foregroundRequests.Add(-1)
}
domainHandler.ServeHTTP(w, r)
})
h = s.withStandbyReadOnly(h)
h = mw.NormalizePath(h)
h = mw.RequestID(h)
h = mw.Logging(h)
h = mw.Recovery(h)
return h
}
func (s *Server) Run(addr string) error {
log.Printf(
"listen %s",
addr,
)
return http.ListenAndServe(
addr,
s.handler(),
)
}