org1/gitea-pages
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

重构项目

Browse Source
This commit is contained in:
dragon
2025-05-08 17:36:24 +08:00
parent ddd5d4af5b
commit 9413188aa9
15 changed files with 404 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
pkg/core/alias.go
View File

@@ -2,6 +2,7 @@ package core
import (
"encoding/json"
"fmt"
"gopkg.d7z.net/gitea-pages/pkg/utils"
)
@@ -13,10 +14,10 @@ type Alias struct {
}
type DomainAlias struct {
config utils.Config
config utils.KVConfig
}
func NewDomainAlias(config utils.Config) *DomainAlias {
func NewDomainAlias(config utils.KVConfig) *DomainAlias {
return &DomainAlias{config: config}
}
@@ -32,17 +33,34 @@ func (a *DomainAlias) Query(domain string) (*Alias, error) {
return rel, nil
}
func (a *DomainAlias) Bind(domain, owner, repo, branch string) error {
save := &Alias{
func (a *DomainAlias) Bind(domains []string, owner, repo, branch string) error {
oldDomains := make([]string, 0)
rKey := fmt.Sprintf("domain/r-alias/%s/%s/%s", owner, repo, branch)
if oldStr, err := a.config.Get(rKey); err == nil {
_ = json.Unmarshal([]byte(oldStr), &oldDomains)
}
for _, oldDomain := range oldDomains {
if err := a.Unbind(oldDomain); err != nil {
return err
}
}
if domains == nil || len(domains) == 0 {
return nil
}
aliasMeta := &Alias{
Owner: owner,
Repo: repo,
Branch: branch,
}
saveB, err := json.Marshal(save)
if err != nil {
return err
aliasMetaRaw, _ := json.Marshal(aliasMeta)
domainsRaw, _ := json.Marshal(domains)
_ = a.config.Put(rKey, string(domainsRaw), utils.TtlKeep)
for _, domain := range domains {
if err := a.config.Put("domain/alias/"+domain, string(aliasMetaRaw), utils.TtlKeep); err != nil {
return err
}
}
return a.config.Put("domain/alias/"+domain, string(saveB), utils.TtlKeep)
return nil
}
func (a *DomainAlias) Unbind(domain string) error {

9
pkg/core/backend.go
View File

@@ -23,6 +23,7 @@ type BranchInfo struct {
}
type Backend interface {
Close() error
// Repos return repo name + default branch
Repos(owner string) (map[string]string, error)
// Branches return branch + commit id
@@ -33,11 +34,15 @@ type Backend interface {
type CacheBackend struct {
backend Backend
config utils.Config
config utils.KVConfig
ttl time.Duration
}
func NewCacheBackend(backend Backend, config utils.Config, ttl time.Duration) *CacheBackend {
func (c *CacheBackend) Close() error {
return c.backend.Close()
}
func NewCacheBackend(backend Backend, config utils.KVConfig, ttl time.Duration) *CacheBackend {
return &CacheBackend{backend: backend, config: config, ttl: ttl}
}

35
pkg/core/domain.go
View File

@@ -1,9 +1,7 @@
package core
import (
"fmt"
"os"
"regexp"
"strings"
"gopkg.d7z.net/gitea-pages/pkg/utils"
@@ -12,8 +10,6 @@ import (
"go.uber.org/zap"
)
var portExp = regexp.MustCompile(`:\d+$`)
type PageDomain struct {
*ServerMeta
@@ -22,7 +18,7 @@ type PageDomain struct {
defaultBranch string
}
func NewPageDomain(meta *ServerMeta, config utils.Config, baseDomain, defaultBranch string) *PageDomain {
func NewPageDomain(meta *ServerMeta, config utils.KVConfig, baseDomain, defaultBranch string) *PageDomain {
return &PageDomain{
baseDomain: baseDomain,
defaultBranch: defaultBranch,
@@ -39,46 +35,40 @@ type PageDomainContent struct {
Path string
}
func (m *PageDomainContent) CacheKey() string {
return fmt.Sprintf("%s/%s/%s/%s", m.Owner, m.Repo, m.CommitID, m.Path)
}
func (p *PageDomain) ParseDomainMeta(domain, path, branch string) (*PageDomainContent, error) {
if branch == "" {
branch = p.defaultBranch
}
domain = portExp.ReplaceAllString(strings.ToLower(domain), "")
pathS := strings.Split(strings.TrimPrefix(path, "/"), "/")
pathArr := strings.Split(strings.TrimPrefix(path, "/"), "/")
if !strings.HasSuffix(domain, "."+p.baseDomain) {
alias, err := p.alias.Query(domain)
alias, err := p.alias.Query(domain) // 确定 alias 是否存在内容
if err != nil {
zap.L().Warn("未知域名", zap.String("base", p.baseDomain), zap.String("domain", domain), zap.Error(err))
return nil, os.ErrNotExist
}
zap.L().Debug("命中别名", zap.String("domain", domain), zap.Any("alias", alias))
return p.ReturnMeta(alias.Owner, alias.Repo, alias.Branch, pathS)
return p.ReturnMeta(alias.Owner, alias.Repo, alias.Branch, pathArr)
}
owner := strings.TrimSuffix(domain, "."+p.baseDomain)
repo := pathS[0]
repo := pathArr[0]
if repo == "" {
// 回退到默认仓库
repo = p.baseDomain
zap.L().Debug("fail back to default repo", zap.String("repo", repo))
}
returnMeta, err := p.ReturnMeta(owner, repo, branch, pathS[1:])
returnMeta, err := p.ReturnMeta(owner, repo, branch, pathArr[1:])
if err != nil && !errors.Is(err, os.ErrNotExist) {
return nil, err
} else if err == nil {
return returnMeta, nil
}
// 回退到默认页面
return p.ReturnMeta(owner, repo, domain, pathS)
return p.ReturnMeta(owner, repo, domain, pathArr)
}
func (p *PageDomain) ReturnMeta(owner string, repo string, branch string, path []string) (*PageDomainContent, error) {
rel := &PageDomainContent{}
if meta, err := p.GetMeta(p.baseDomain, owner, repo, branch); err == nil {
if meta, err := p.GetMeta(owner, repo, branch); err == nil {
rel.PageMetaContent = meta
rel.Owner = owner
rel.Repo = repo
@@ -86,13 +76,10 @@ func (p *PageDomain) ReturnMeta(owner string, repo string, branch string, path [
if strings.HasSuffix(rel.Path, "/") || rel.Path == "" {
rel.Path = rel.Path + "index.html"
}
if meta.Domain != "" {
err = p.alias.Bind(meta.Domain, rel.Owner, rel.Repo, branch)
if err != nil {
zap.L().Warn("别名绑定失败", zap.Error(err))
}
if err = p.alias.Bind(meta.Alias, rel.Owner, rel.Repo, branch); err != nil {
zap.L().Warn("别名绑定失败", zap.Error(err))
return nil, err
}
return rel, nil
} else {
zap.L().Debug("查询错误", zap.Error(err))

123
pkg/core/meta.go
View File

@@ -5,17 +5,17 @@ import (
"fmt"
"io"
"net/http"
"net/url"
"os"
"regexp"
"strings"
"time"
"gopkg.d7z.net/gitea-pages/pkg/renders"
"go.uber.org/zap"
"gopkg.in/yaml.v3"
"github.com/gobwas/glob"
"go.uber.org/zap"
"github.com/pkg/errors"
"gopkg.d7z.net/gitea-pages/pkg/utils"
@@ -26,8 +26,10 @@ var regexpHostname = regexp.MustCompile(`^(?:([a-z0-9-]+|\*)\.)?([a-z0-9-]{1,61}
type ServerMeta struct {
Backend
Domain string
client *http.Client
cache utils.Config
cache utils.KVConfig
ttl time.Duration
locker *utils.Locker
@@ -35,17 +37,28 @@ type ServerMeta struct {
type renderCompiler struct {
regex glob.Glob
renders.Render
Render
}
// PageConfig 配置
type PageConfig struct {
Alias []string `yaml:"required"` // 重定向地址
Renders map[string]string `yaml:"templates"` // 渲染器地址
VirtualRoute bool `yaml:"v-route"` // 是否使用虚拟路由（任何路径均使用 /index.html 返回 200 响应）
ReverseProxy map[string]string `yaml:"proxy"` // 反向代理路由
}
type PageMetaContent struct {
CommitID string `json:"id"` // 提交 COMMIT ID
IsPage bool `json:"pg"` // 是否为 Page
Domain string `json:"domain"` // 匹配的域名
HistoryRouteMode bool `json:"historyRouteMode"` // 路由模式
CustomNotFound bool `json:"404"` // 注册了自定义 404 页面
LastModified time.Time `json:"up"` // 上次更新时间
Renders map[string][]string `json:"renders"` // 配置的渲染器
CommitID string `json:"commit-id"` // 提交 COMMIT ID
LastModified time.Time `json:"last-modified"` // 上次更新时间
IsPage bool `json:"is-page"` // 是否为 Page
ErrorMsg string `json:"error"` // 错误消息
VRoute bool `yaml:"v-route"` // 虚拟路由
Alias []string `yaml:"aliases"` // 重定向
Proxy map[string]string `yaml:"proxy"` // 反向代理
Renders map[string][]string `json:"renders"` // 配置的渲染器
rendersL []*renderCompiler
}
@@ -57,14 +70,14 @@ func (m *PageMetaContent) From(data string) error {
for _, g := range gs {
m.rendersL = append(m.rendersL, &renderCompiler{
regex: glob.MustCompile(g),
Render: renders.GetRender(key),
Render: GetRender(key),
})
}
}
return err
}
func (m *PageMetaContent) TryRender(path ...string) renders.Render {
func (m *PageMetaContent) TryRender(path ...string) Render {
for _, s := range path {
for _, compiler := range m.rendersL {
if compiler.regex.Match(s) {
@@ -80,13 +93,15 @@ func (m *PageMetaContent) String() string {
return string(marshal)
}
func NewServerMeta(client *http.Client, backend Backend, config utils.Config, ttl time.Duration) *ServerMeta {
return &ServerMeta{backend, client, config, ttl, utils.NewLocker()}
func NewServerMeta(client *http.Client, backend Backend, kv utils.KVConfig, domain string, ttl time.Duration) *ServerMeta {
return &ServerMeta{backend, domain, client, kv, ttl, utils.NewLocker()}
}
func (s *ServerMeta) GetMeta(baseDomain, owner, repo, branch string) (*PageMetaContent, error) {
func (s *ServerMeta) GetMeta(owner, repo, branch string) (*PageMetaContent, error) {
rel := &PageMetaContent{
IsPage: false,
Proxy: make(map[string]string),
Alias: make([]string, 0),
Renders: make(map[string][]string),
}
if repos, err := s.Repos(owner); err != nil {
@@ -144,41 +159,67 @@ func (s *ServerMeta) GetMeta(baseDomain, owner, repo, branch string) (*PageMetaC
} else {
rel.IsPage = true
}
rel.CustomNotFound, _ = s.FileExists(owner, repo, rel.CommitID, "404.html")
if cname, err := s.ReadString(owner, repo, rel.CommitID, "CNAME"); err == nil {
cname = strings.TrimSpace(cname)
if regexpHostname.MatchString(cname) && !strings.HasSuffix(strings.ToLower(cname), strings.ToLower(baseDomain)) {
rel.Domain = cname
} else {
zap.L().Debug("指定的 CNAME 不合法", zap.String("cname", cname))
}
errFunc := func(err error) (*PageMetaContent, error) {
rel.IsPage = false
rel.ErrorMsg = err.Error()
_ = s.cache.Put(key, rel.String(), s.ttl)
return nil, err
}
if r, err := s.ReadString(owner, repo, rel.CommitID, ".render"); err == nil {
for _, render := range strings.Split(r, "\n") {
render = strings.TrimSpace(render)
if strings.HasPrefix(render, "#") {
continue
if data, err := s.ReadString(owner, repo, rel.CommitID, ".pages.yaml"); err == nil {
cfg := new(PageConfig)
if err = yaml.Unmarshal([]byte(data), cfg); err != nil {
return errFunc(err)
}
rel.Alias = cfg.Alias
rel.VRoute = cfg.VirtualRoute
for _, cname := range cfg.Alias {
cname = strings.TrimSpace(cname)
if regexpHostname.MatchString(cname) && !strings.HasSuffix(strings.ToLower(cname), strings.ToLower(s.Domain)) {
rel.Alias = append(rel.Alias, cname)
} else {
return errFunc(errors.New("invalid alias name " + cname))
}
before, after, found := strings.Cut(render, " ")
before = strings.TrimSpace(before)
after = strings.TrimSpace(after)
if found {
if r := renders.GetRender(before); r != nil {
if g, err := glob.Compile(after); err == nil {
rel.Renders[before] = append(rel.Renders[before], after)
}
for sType, patterns := range cfg.Renders {
if r := GetRender(sType); r != nil {
for _, pattern := range strings.Split(patterns, ",") {
rel.Renders[sType] = append(rel.Renders[sType], pattern)
if g, err := glob.Compile(strings.TrimSpace(pattern)); err == nil {
rel.rendersL = append(rel.rendersL, &renderCompiler{
regex: g,
Render: r,
})
} else {
return errFunc(err)
}
}
}
}
for path, backend := range cfg.ReverseProxy {
path = strings.TrimSpace(path)
path = strings.ReplaceAll(path, "//", "/")
path = strings.ReplaceAll(path, "//", "/")
if !strings.HasPrefix(path, "/") {
path = "/" + path
}
if strings.HasSuffix(path, "/") {
path = path[:len(path)-1]
}
var rUrl *url.URL
if rUrl, err = url.Parse(backend); err != nil {
return errFunc(err)
}
if rUrl.Scheme != "http" && rUrl.Scheme != "https" {
return errFunc(errors.New("invalid backend url " + backend))
}
rel.Proxy[path] = rUrl.String()
}
} else {
// 不存在配置，但也可以重定向
zap.L().Debug("failed to read meta data", zap.String("error", err.Error()))
}
if find, _ := s.FileExists(owner, repo, rel.CommitID, ".history"); find {
rel.HistoryRouteMode = true
}
_ = s.cache.Put(key, rel.String(), s.ttl)
return rel, nil
}

29
pkg/core/render.go Normal file
View File

@@ -0,0 +1,29 @@
package core
import (
"io"
"net/http"
"sync"
)
var (
renders = make(map[string]Render)
lock = &sync.Mutex{}
)
type Render interface {
Render(w http.ResponseWriter, r *http.Request, input io.Reader) error
}
func RegisterRender(fType string, r Render) {
lock.Lock()
defer lock.Unlock()
if renders[fType] != nil {
panic("duplicate render type: " + fType)
}
renders[fType] = r
}
func GetRender(key string) Render {
return renders[key]
}