139 lines
3.7 KiB
Go
139 lines
3.7 KiB
Go
package pkg
|
|
|
|
import (
|
|
"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/middleware/kv"
|
|
)
|
|
|
|
var portExp = regexp.MustCompile(`:\d+$`)
|
|
|
|
type Server struct {
|
|
backend core.Backend
|
|
meta *core.PageDomain
|
|
|
|
errorHandler func(w http.ResponseWriter, r *http.Request, err error)
|
|
|
|
filterMgr map[string]core.FilterInstance
|
|
globCache *lru.Cache[string, glob.Glob]
|
|
}
|
|
|
|
func NewPageServer(
|
|
client *http.Client,
|
|
backend core.Backend,
|
|
domain string,
|
|
defaultBranch string,
|
|
db kv.KV,
|
|
cache kv.KV,
|
|
cacheTTL time.Duration,
|
|
errorHandler func(w http.ResponseWriter, r *http.Request, err error),
|
|
) *Server {
|
|
svcMeta := core.NewServerMeta(client, backend, domain, cache, cacheTTL)
|
|
cfgDB := db.Child("config")
|
|
pageMeta := core.NewPageDomain(svcMeta,
|
|
core.NewDomainAlias(cfgDB.Child("alias")),
|
|
cfgDB.Child("pages"),
|
|
domain, defaultBranch)
|
|
c, err := lru.New[string, glob.Glob](256)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return &Server{
|
|
backend: backend,
|
|
meta: pageMeta,
|
|
globCache: c,
|
|
filterMgr: filters.DefaultFilters(),
|
|
errorHandler: errorHandler,
|
|
}
|
|
}
|
|
|
|
func (s *Server) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
|
|
sessionID, _ := uuid.NewRandom()
|
|
request.Header.Set("Session-ID", sessionID.String())
|
|
//if s.staticFS != nil && strings.HasPrefix(request.URL.Path, staticPrefix) {
|
|
// s.staticFS.ServeHTTP(writer, request)
|
|
// return
|
|
//}
|
|
defer func() {
|
|
if e := recover(); e != nil {
|
|
zap.L().Error("panic!", zap.Any("error", e), zap.Any("id", sessionID))
|
|
if err, ok := e.(error); ok {
|
|
s.errorHandler(writer, request, err)
|
|
}
|
|
}
|
|
}()
|
|
err := s.Serve(writer, request)
|
|
if err != nil {
|
|
zap.L().Debug("错误请求", zap.Error(err), zap.Any("request", request.RequestURI), zap.Any("id", sessionID))
|
|
s.errorHandler(writer, request, err)
|
|
}
|
|
}
|
|
|
|
func (s *Server) Serve(writer http.ResponseWriter, request *http.Request) error {
|
|
ctx := request.Context()
|
|
domain := portExp.ReplaceAllString(strings.ToLower(request.Host), "")
|
|
meta, err := s.meta.ParseDomainMeta(ctx, domain, request.URL.Path, request.URL.Query().Get("branch"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
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 {
|
|
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)
|
|
|
|
l := len(filtersRoute)
|
|
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(ctx, writer, request, meta)
|
|
return err
|
|
}
|