112 lines
2.8 KiB
Go
112 lines
2.8 KiB
Go
package pkg
|
|
|
|
import (
|
|
"io"
|
|
"mime"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"github.com/pkg/errors"
|
|
"go.uber.org/zap"
|
|
|
|
"code.d7z.net/d7z-project/gitea-pages/pkg/core"
|
|
"code.d7z.net/d7z-project/gitea-pages/pkg/utils"
|
|
"github.com/pbnjay/memory"
|
|
)
|
|
|
|
type ServerOptions struct {
|
|
Domain string
|
|
DefaultBranch string
|
|
|
|
Config utils.Config
|
|
Cache utils.Cache
|
|
|
|
MaxCacheSize int
|
|
|
|
HttpClient *http.Client
|
|
}
|
|
|
|
func DefaultOptions(domain string) ServerOptions {
|
|
configMemory, _ := utils.NewConfigMemory("")
|
|
return ServerOptions{
|
|
Domain: domain,
|
|
DefaultBranch: "gh-pages",
|
|
Config: configMemory,
|
|
Cache: utils.NewCacheMemory(1024*1024*10, int(memory.FreeMemory()/3*2)),
|
|
MaxCacheSize: 1024 * 1024 * 10,
|
|
HttpClient: http.DefaultClient,
|
|
}
|
|
}
|
|
|
|
type Server struct {
|
|
meta *core.PageDomain
|
|
options *ServerOptions
|
|
reader *core.CacheBackendBlobReader
|
|
}
|
|
|
|
func NewPageServer(backend core.Backend, options ServerOptions) *Server {
|
|
backend = core.NewCacheBackend(backend, options.Config, time.Minute)
|
|
svcMeta := core.NewServerMeta(options.HttpClient, backend, options.Config, time.Minute)
|
|
pageMeta := core.NewPageDomain(svcMeta, options.Domain, options.DefaultBranch)
|
|
reader := core.NewCacheBackendBlobReader(options.HttpClient, backend, options.Cache, options.MaxCacheSize)
|
|
return &Server{
|
|
meta: pageMeta,
|
|
options: &options,
|
|
reader: reader,
|
|
}
|
|
}
|
|
|
|
func (s *Server) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
|
|
meta, err := s.meta.ParseDomainMeta(request.Host, request.URL.Path, request.URL.Query().Get("branch"))
|
|
if err != nil {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
s.writeNotfoundError(writer, request.RequestURI)
|
|
} else {
|
|
s.writeError(writer, err)
|
|
}
|
|
return
|
|
}
|
|
result, err := s.reader.Open(meta.Owner, meta.Repo, meta.CommitID, meta.Path)
|
|
if err != nil {
|
|
// todo: 添加默认返回
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
s.writeNotfoundError(writer, request.RequestURI)
|
|
} else {
|
|
s.writeError(writer, err)
|
|
}
|
|
return
|
|
}
|
|
fileName := filepath.Base(meta.Path)
|
|
if reader, ok := result.(*utils.CacheContent); ok {
|
|
http.ServeContent(writer, request, fileName, reader.LastModified, reader)
|
|
_ = reader.Close()
|
|
return
|
|
}
|
|
writer.Header().Set("Content-Type", mime.TypeByExtension(meta.Path))
|
|
writer.WriteHeader(http.StatusOK)
|
|
_, _ = io.Copy(writer, result)
|
|
_ = result.Close()
|
|
return
|
|
}
|
|
|
|
func (s *Server) writeError(writer http.ResponseWriter, err error) {
|
|
zap.L().Error("write error", zap.Error(err))
|
|
http.Error(writer, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
|
|
func (s *Server) writeNotfoundError(writer http.ResponseWriter, path string) {
|
|
http.Error(writer, "page not found.", http.StatusNotFound)
|
|
}
|
|
|
|
func (s *Server) Close() error {
|
|
if err := s.options.Config.Close(); err != nil {
|
|
return err
|
|
}
|
|
if err := s.options.Cache.Close(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|