271 lines
7.2 KiB
Go
271 lines
7.2 KiB
Go
package pkg
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"regexp"
|
|
"slices"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gobwas/glob"
|
|
"github.com/google/uuid"
|
|
lru "github.com/hashicorp/golang-lru/v2"
|
|
"go.uber.org/zap"
|
|
"gopkg.d7z.net/gitea-pages/pkg/core"
|
|
"gopkg.d7z.net/gitea-pages/pkg/filters"
|
|
"gopkg.d7z.net/gitea-pages/pkg/utils"
|
|
"gopkg.d7z.net/middleware/cache"
|
|
"gopkg.d7z.net/middleware/kv"
|
|
"gopkg.d7z.net/middleware/subscribe"
|
|
"gopkg.d7z.net/middleware/tools"
|
|
)
|
|
|
|
var portExp = regexp.MustCompile(`:\d+$`)
|
|
|
|
type Server struct {
|
|
backend core.Backend
|
|
meta *core.PageDomain
|
|
db kv.KV
|
|
filterMgr map[string]core.FilterInstance
|
|
|
|
globCache *lru.Cache[string, glob.Glob]
|
|
|
|
cacheBlob cache.Cache
|
|
cacheBlobTTL time.Duration
|
|
|
|
event subscribe.Subscriber
|
|
errorHandler func(w http.ResponseWriter, r *http.Request, err error)
|
|
}
|
|
|
|
type serverConfig struct {
|
|
client *http.Client
|
|
event subscribe.Subscriber
|
|
cacheMeta kv.KV
|
|
cacheMetaTTL time.Duration
|
|
cacheMetaRefresh time.Duration
|
|
cacheMetaRefreshConcurrent int
|
|
cacheBlob cache.Cache
|
|
cacheBlobTTL time.Duration
|
|
errorHandler func(w http.ResponseWriter, r *http.Request, err error)
|
|
filterConfig map[string]map[string]any
|
|
}
|
|
|
|
type ServerOption func(*serverConfig)
|
|
|
|
func WithClient(client *http.Client) ServerOption {
|
|
return func(c *serverConfig) {
|
|
c.client = client
|
|
}
|
|
}
|
|
|
|
func WithEvent(event subscribe.Subscriber) ServerOption {
|
|
return func(c *serverConfig) {
|
|
c.event = event
|
|
}
|
|
}
|
|
|
|
func WithMetaCache(cache kv.KV, ttl time.Duration, refresh time.Duration, refreshConcurrent int) ServerOption {
|
|
return func(c *serverConfig) {
|
|
c.cacheMeta = cache
|
|
c.cacheMetaTTL = ttl
|
|
c.cacheMetaRefresh = refresh
|
|
c.cacheMetaRefreshConcurrent = refreshConcurrent
|
|
}
|
|
}
|
|
|
|
func WithBlobCache(cache cache.Cache, ttl time.Duration) ServerOption {
|
|
return func(c *serverConfig) {
|
|
c.cacheBlob = cache
|
|
c.cacheBlobTTL = ttl
|
|
}
|
|
}
|
|
|
|
func WithErrorHandler(handler func(w http.ResponseWriter, r *http.Request, err error)) ServerOption {
|
|
return func(c *serverConfig) {
|
|
c.errorHandler = handler
|
|
}
|
|
}
|
|
|
|
func WithFilterConfig(config map[string]map[string]any) ServerOption {
|
|
return func(c *serverConfig) {
|
|
c.filterConfig = config
|
|
}
|
|
}
|
|
|
|
func NewPageServer(
|
|
backend core.Backend,
|
|
domain string,
|
|
db kv.KV,
|
|
opts ...ServerOption,
|
|
) (*Server, error) {
|
|
cfg := &serverConfig{
|
|
client: http.DefaultClient,
|
|
filterConfig: make(map[string]map[string]any),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(cfg)
|
|
}
|
|
|
|
if cfg.event == nil {
|
|
cfg.event = subscribe.NewMemorySubscriber()
|
|
}
|
|
|
|
if cfg.cacheMeta == nil {
|
|
var err error
|
|
cfg.cacheMeta, err = kv.NewMemory("")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if cfg.cacheMetaRefresh == 0 {
|
|
cfg.cacheMetaRefresh = cfg.cacheMetaTTL / 2
|
|
}
|
|
|
|
if cfg.cacheMetaRefreshConcurrent == 0 {
|
|
cfg.cacheMetaRefreshConcurrent = 16
|
|
}
|
|
|
|
if cfg.cacheBlob == nil {
|
|
var err error
|
|
cfg.cacheBlob, err = cache.NewMemoryCache(cache.MemoryCacheConfig{
|
|
MaxCapacity: 128,
|
|
CleanupInt: time.Minute,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if cfg.errorHandler == nil {
|
|
cfg.errorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
alias := core.NewDomainAlias(db.Child("config", "alias"))
|
|
svcMeta := core.NewServerMeta(cfg.client, backend, domain, alias, cfg.cacheMeta, cfg.cacheMetaTTL, cfg.cacheMetaRefresh, cfg.cacheMetaRefreshConcurrent)
|
|
pageMeta := core.NewPageDomain(svcMeta, domain)
|
|
globCache, err := lru.New[string, glob.Glob](512)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defaultFilters, err := filters.DefaultFilters(cfg.filterConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Server{
|
|
backend: backend,
|
|
meta: pageMeta,
|
|
db: db,
|
|
globCache: globCache,
|
|
filterMgr: defaultFilters,
|
|
errorHandler: cfg.errorHandler,
|
|
cacheBlob: cfg.cacheBlob,
|
|
cacheBlobTTL: cfg.cacheBlobTTL,
|
|
event: cfg.event,
|
|
}, nil
|
|
}
|
|
|
|
func (s *Server) ServeHTTP(w http.ResponseWriter, request *http.Request) {
|
|
sessionID, _ := uuid.NewRandom()
|
|
request.Header.Set("Session-ID", sessionID.String())
|
|
writer := utils.NewWrittenResponseWriter(w)
|
|
defer func() {
|
|
if e := recover(); e != nil {
|
|
zap.L().Error("panic!", zap.Any("error", e), zap.Any("id", sessionID))
|
|
if !writer.IsWritten() {
|
|
if err, ok := e.(error); ok {
|
|
s.errorHandler(writer, request, err)
|
|
} else {
|
|
s.errorHandler(writer, request, errors.New("panic"))
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
err := s.Serve(writer, request)
|
|
if err != nil {
|
|
zap.L().Debug("bad request", zap.Error(err), zap.Any("request", request.RequestURI), zap.Any("id", sessionID))
|
|
if !writer.IsWritten() {
|
|
s.errorHandler(writer, request, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Server) Serve(writer *utils.WrittenResponseWriter, request *http.Request) error {
|
|
ctx := request.Context()
|
|
domain := portExp.ReplaceAllString(strings.ToLower(request.Host), "")
|
|
meta, err := s.meta.ParseDomainMeta(ctx, domain, request.URL.Path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
writer.Header().Set("X-Page-ID", meta.CommitID)
|
|
cancelCtx, cancelFunc := context.WithCancel(request.Context())
|
|
filterCtx := core.FilterContext{
|
|
PageContent: meta,
|
|
Context: cancelCtx,
|
|
PageVFS: core.NewPageVFS(s.backend, meta.Owner, meta.Repo, meta.CommitID),
|
|
Cache: tools.NewTTLCache(s.cacheBlob.Child("filter", meta.Owner, meta.Repo, meta.CommitID), s.cacheBlobTTL),
|
|
OrgDB: s.db.Child("org", meta.Owner),
|
|
RepoDB: s.db.Child("repo", meta.Owner, meta.Repo),
|
|
Event: s.event.Child("domain", meta.Owner, meta.Repo),
|
|
|
|
Kill: cancelFunc,
|
|
}
|
|
|
|
zap.L().Debug("new request", zap.Any("request path", meta.Path))
|
|
|
|
if strings.HasSuffix(meta.Path, "/") || meta.Path == "" {
|
|
meta.Path += "index.html"
|
|
}
|
|
activeFiltersCall := make([]core.FilterCall, 0)
|
|
activeFilters := make([]core.Filter, 0)
|
|
filtersRoute := make([]string, 0)
|
|
|
|
for _, filter := range meta.Filters {
|
|
value, ok := s.globCache.Get(filter.Path)
|
|
if !ok {
|
|
value, err = glob.Compile(filter.Path)
|
|
if err != nil {
|
|
zap.L().Warn("invalid glob pattern", zap.String("pattern", filter.Path), zap.Error(err))
|
|
continue
|
|
}
|
|
s.globCache.Add(filter.Path, value)
|
|
}
|
|
if value.Match(meta.Path) {
|
|
instance := s.filterMgr[filter.Type]
|
|
if instance == nil {
|
|
return errors.New("filter not found : " + filter.Type)
|
|
}
|
|
activeFilters = append(activeFilters, filter)
|
|
filtersRoute = append(filtersRoute, fmt.Sprintf("%s[%s]%s", filter.Type, filter.Path, filter.Params))
|
|
call, err := instance(filter.Params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
activeFiltersCall = append(activeFiltersCall, call)
|
|
}
|
|
}
|
|
slices.Reverse(activeFiltersCall)
|
|
slices.Reverse(activeFilters)
|
|
|
|
// Build the visual call stack for logging (e.g., A -> B -> C -> B -> A)
|
|
l := len(filtersRoute)
|
|
if l > 1 {
|
|
for i := l - 2; i >= 0; i-- {
|
|
filtersRoute = append(filtersRoute, filtersRoute[i])
|
|
}
|
|
}
|
|
zap.L().Debug("active filters", zap.String("filters", strings.Join(filtersRoute, " -> ")))
|
|
|
|
var stack core.NextCall = core.NotFountNextCall
|
|
for i, filter := range activeFiltersCall {
|
|
stack = core.NextCallWrapper(filter, stack, activeFilters[i])
|
|
}
|
|
err = stack(filterCtx, writer, request)
|
|
return err
|
|
}
|