260 lines
7.4 KiB
Go
260 lines
7.4 KiB
Go
package pkg
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httputil"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"slices"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"gopkg.d7z.net/middleware/cache"
|
|
"gopkg.d7z.net/middleware/kv"
|
|
|
|
stdErr "errors"
|
|
|
|
"github.com/pkg/errors"
|
|
"go.uber.org/zap"
|
|
|
|
"gopkg.d7z.net/gitea-pages/pkg/core"
|
|
"gopkg.d7z.net/gitea-pages/pkg/utils"
|
|
)
|
|
|
|
var portExp = regexp.MustCompile(`:\d+$`)
|
|
|
|
type ServerOptions struct {
|
|
Domain string // 默认域名
|
|
DefaultBranch string // 默认分支
|
|
|
|
Alias kv.KV // 配置映射关系
|
|
|
|
CacheMeta kv.KV // 配置缓存
|
|
CacheMetaTTL time.Duration // 配置缓存时长
|
|
|
|
CacheBlob cache.Cache // blob缓存
|
|
CacheBlobTTL time.Duration // 配置缓存时长
|
|
CacheControl string // 缓存配置
|
|
|
|
CacheBlobLimit uint64 // blob最大缓存大小
|
|
|
|
HTTPClient *http.Client // 自定义客户端
|
|
EnableRender bool // 允许渲染
|
|
|
|
EnableProxy bool // 允许代理
|
|
|
|
StaticDir string // 静态文件位置
|
|
DefaultErrorHandler func(w http.ResponseWriter, r *http.Request, err error)
|
|
}
|
|
|
|
func DefaultOptions(domain string) ServerOptions {
|
|
configMemory, _ := kv.NewMemory("")
|
|
cacheMemory, _ := cache.NewMemoryCache(cache.MemoryCacheConfig{MaxCapacity: 4096, CleanupInt: time.Hour})
|
|
return ServerOptions{
|
|
Domain: domain,
|
|
DefaultBranch: "gh-pages",
|
|
|
|
Alias: configMemory,
|
|
CacheMeta: configMemory,
|
|
CacheMetaTTL: time.Minute,
|
|
|
|
CacheBlob: cacheMemory,
|
|
CacheBlobTTL: time.Minute,
|
|
CacheBlobLimit: 1024 * 1024 * 10,
|
|
CacheControl: "public, max-age=86400",
|
|
|
|
HTTPClient: http.DefaultClient,
|
|
|
|
EnableRender: true,
|
|
EnableProxy: true,
|
|
StaticDir: "",
|
|
DefaultErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
http.Error(w, "page not found.", http.StatusNotFound)
|
|
} else if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
type Server struct {
|
|
options *ServerOptions
|
|
meta *core.PageDomain
|
|
backend core.Backend
|
|
fs http.Handler
|
|
}
|
|
|
|
var staticPrefix = "/.well-known/page-server/"
|
|
|
|
func NewPageServer(backend core.Backend, options ServerOptions) *Server {
|
|
backend = core.NewCacheBackend(backend, options.CacheMeta, options.CacheMetaTTL,
|
|
options.CacheBlob, options.CacheBlobLimit,
|
|
)
|
|
svcMeta := core.NewServerMeta(options.HTTPClient, backend, options.CacheMeta, options.Domain, options.CacheMetaTTL)
|
|
pageMeta := core.NewPageDomain(svcMeta, options.Alias, options.Domain, options.DefaultBranch)
|
|
var fs http.Handler
|
|
if options.StaticDir != "" {
|
|
fs = http.StripPrefix(staticPrefix, http.FileServer(http.Dir(options.StaticDir)))
|
|
}
|
|
return &Server{
|
|
backend: backend,
|
|
options: &options,
|
|
meta: pageMeta,
|
|
fs: fs,
|
|
}
|
|
}
|
|
|
|
func (s *Server) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
|
|
sessionID, _ := uuid.NewRandom()
|
|
request.Header.Set("Session-ID", sessionID.String())
|
|
if s.fs != nil && strings.HasPrefix(request.URL.Path, staticPrefix) {
|
|
s.fs.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.options.DefaultErrorHandler(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.options.DefaultErrorHandler(writer, request, err)
|
|
}
|
|
}
|
|
|
|
func (s *Server) Serve(writer http.ResponseWriter, request *http.Request) error {
|
|
ctx := request.Context()
|
|
domainHost := portExp.ReplaceAllString(strings.ToLower(request.Host), "")
|
|
|
|
meta, err := s.meta.ParseDomainMeta(ctx, domainHost, 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 len(meta.Alias) > 0 && !slices.Contains(meta.Alias, domainHost) {
|
|
// 重定向到配置的地址
|
|
zap.L().Debug("redirect", zap.Any("src", request.Host), zap.Any("dst", meta.Alias[0]))
|
|
http.Redirect(writer, request, fmt.Sprintf("https://%s/%s", meta.Alias[0], meta.Path), http.StatusFound)
|
|
return nil
|
|
}
|
|
// 处理反向代理
|
|
if s.options.EnableProxy && s.Proxy(writer, request, meta) {
|
|
return nil
|
|
}
|
|
// 在非反向代理时处理目录访问
|
|
if strings.HasSuffix(meta.Path, "/") || meta.Path == "" {
|
|
meta.Path += "index.html"
|
|
}
|
|
// 如果不是反向代理路由则跳过任何配置
|
|
if request.Method != http.MethodGet {
|
|
return os.ErrNotExist
|
|
}
|
|
if meta.IgnorePath(meta.Path) {
|
|
zap.L().Debug("ignore path", zap.Any("request", request.RequestURI), zap.Any("meta.path", meta.Path))
|
|
err = os.ErrNotExist
|
|
}
|
|
type resp struct {
|
|
IsError bool
|
|
Path string
|
|
}
|
|
|
|
callPath := []resp{{false, meta.Path}}
|
|
if meta.VRoute {
|
|
callPath = append(callPath, resp{false, "index.html"})
|
|
} else {
|
|
callPath = append(callPath, resp{false, meta.Path + "/index.html"})
|
|
}
|
|
callPath = append(callPath, resp{true, "404.html"})
|
|
|
|
var callResp *http.Response
|
|
callErr := os.ErrNotExist
|
|
var callRespMeta resp
|
|
for _, r := range callPath {
|
|
callResp, callErr = meta.NativeOpen(request.Context(), r.Path, nil)
|
|
if callErr != nil {
|
|
if callResp != nil {
|
|
_ = callResp.Body.Close()
|
|
}
|
|
if !errors.Is(callErr, os.ErrNotExist) {
|
|
zap.L().Debug("error", zap.Any("error", callErr))
|
|
}
|
|
callRespMeta = r
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
|
|
if callResp == nil {
|
|
return os.ErrNotExist
|
|
}
|
|
if callErr != nil {
|
|
// 回退失败
|
|
return callErr
|
|
}
|
|
render := meta.TryRender(meta.Path)
|
|
writer.Header().Set("Content-Type", callResp.Header.Get("Content-Type"))
|
|
if callRespMeta.IsError {
|
|
render = meta.TryRender(meta.Path)
|
|
writer.WriteHeader(http.StatusNotFound)
|
|
} else if render == nil {
|
|
lastMod, err := time.Parse(http.TimeFormat, callResp.Header.Get("Last-Modified"))
|
|
if seekResp, ok := callResp.Body.(io.ReadSeeker); ok && err == nil {
|
|
http.ServeContent(writer, request, filepath.Base(callRespMeta.Path), lastMod, seekResp)
|
|
}
|
|
} else {
|
|
defer callResp.Body.Close()
|
|
return render.Render(writer, request, callResp.Body)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Server) Proxy(writer http.ResponseWriter, request *http.Request, meta *core.PageDomainContent) bool {
|
|
for prefix, backend := range meta.Proxy {
|
|
proxyPath := "/" + meta.Path
|
|
if strings.HasPrefix(proxyPath, prefix) {
|
|
targetPath := strings.TrimPrefix(proxyPath, prefix)
|
|
if !strings.HasPrefix(targetPath, "/") {
|
|
targetPath = "/" + targetPath
|
|
}
|
|
u, _ := url.Parse(backend)
|
|
request.URL.Path = targetPath
|
|
request.RequestURI = request.URL.RequestURI()
|
|
proxy := httputil.NewSingleHostReverseProxy(u)
|
|
proxy.Transport = s.options.HTTPClient.Transport
|
|
|
|
if host, _, err := net.SplitHostPort(request.RemoteAddr); err == nil {
|
|
request.Header.Set("X-Real-IP", host)
|
|
}
|
|
request.Header.Set("X-Page-IP", utils.GetRemoteIP(request))
|
|
request.Header.Set("X-Page-Refer", fmt.Sprintf("%s/%s/%s", meta.Owner, meta.Repo, meta.Path))
|
|
request.Header.Set("X-Page-Host", request.Host)
|
|
zap.L().Debug("命中反向代理", zap.Any("prefix", prefix), zap.Any("backend", backend),
|
|
zap.Any("path", proxyPath), zap.Any("target", fmt.Sprintf("%s%s", u, targetPath)))
|
|
// todo(security): 处理 websocket
|
|
proxy.ServeHTTP(writer, request)
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (s *Server) Close() error {
|
|
return stdErr.Join(
|
|
s.options.CacheBlob.Close(),
|
|
s.options.CacheMeta.Close(),
|
|
s.options.Alias.Close(),
|
|
s.backend.Close(),
|
|
)
|
|
}
|