caddy-gitea/pkg/gitea/gitea.go

package gitea

import (
	"bytes"
	"fmt"
	"io"
	"io/fs"
	"net/http"
	"net/url"
	"strings"
	"sync"

	gclient "code.gitea.io/sdk/gitea"
	"github.com/spf13/viper"
)

type Client struct {
	serverURL          string
	token              string
	giteapages         string
	giteapagesAllowAll string
	gc                 *gclient.Client
}

func NewClient(serverURL, token, giteapages, giteapagesAllowAll string) (*Client, error) {
	if giteapages == "" {
		giteapages = "gitea-pages"
	}

	if giteapagesAllowAll == "" {
		giteapagesAllowAll = "gitea-pages-allowall"
	}

	gc, err := gclient.NewClient(serverURL, gclient.SetToken(token), gclient.SetGiteaVersion(""))
	if err != nil {
		return nil, err
	}

	return &Client{
		serverURL:          serverURL,
		token:              token,
		gc:                 gc,
		giteapages:         giteapages,
		giteapagesAllowAll: giteapagesAllowAll,
	}, nil
}

func (c *Client) Open(name, ref string) (fs.File, error) {
	owner, repo, filepath := splitName(name)

	if repo == "" {
		repo = owner + ".fluffy.pw"
		filepath = "index.html"
	}

	if filepath == "" {
		filepath = "index.html"
	}

	isFluffyPagesRepo := strings.HasSuffix(repo, ".fluffy.pw")

	limited, allowall := c.allowsPages(owner, repo)
	if !limited && !allowall && !isFluffyPagesRepo {
		return nil, fs.ErrNotExist
	}

	hasConfig := true

	if err := c.readConfig(owner, repo); err != nil {
		if !isFluffyPagesRepo && !allowall {
			return nil, err
		}

		hasConfig = false
	}

	if !hasConfig && !validRefs(ref, allowall || isFluffyPagesRepo) {
		return nil, fs.ErrNotExist
	}

	res, err := c.getRawFileOrLFS(owner, repo, filepath, ref)
	if err != nil {
		return nil, err
	}

	if strings.HasSuffix(filepath, ".md") {
		res, err = handleMD(res)
		if err != nil {
			return nil, err
		}
	}

	return &openFile{
		content: res,
		name:    filepath,
	}, nil
}

func (c *Client) getRawFileOrLFS(owner, repo, filepath, ref string) ([]byte, error) {
	var (
		giteaURL string
		err      error
	)

	// TODO: make pr for go-sdk
	// gitea sdk doesn't support "media" type for lfs/non-lfs
	giteaURL, err = url.JoinPath(c.serverURL+"/api/v1/repos/", owner, repo, "media", filepath)
	if err != nil {
		return nil, err
	}

	giteaURL += "?ref=" + url.QueryEscape(ref)

	req, err := http.NewRequest(http.MethodGet, giteaURL, nil)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Authorization", "token "+c.token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}

	switch resp.StatusCode {
	case http.StatusNotFound:
		return nil, fs.ErrNotExist
	case http.StatusOK:
	default:
		return nil, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
	}

	res, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	defer resp.Body.Close()

	return res, nil
}

var bufPool = sync.Pool{
	New: func() any {
		return new(bytes.Buffer)
	},
}

func handleMD(res []byte) ([]byte, error) {
	meta, resbody, err := extractFrontMatter(string(res))
	if err != nil {
		return nil, err
	}

	resmd, err := markdown([]byte(resbody))
	if err != nil {
		return nil, err
	}

	title, _ := meta["title"].(string)

	res = append([]byte("<!DOCTYPE html>\n<html>\n<body>\n<h1>"), []byte(title)...)
	res = append(res, []byte("</h1>")...)
	res = append(res, resmd...)
	res = append(res, []byte("</body></html>")...)

	return res, nil
}

func (c *Client) repoTopics(owner, repo string) ([]string, error) {
	repos, _, err := c.gc.ListRepoTopics(owner, repo, gclient.ListRepoTopicsOptions{})
	return repos, err
}

func (c *Client) hasRepoBranch(owner, repo, branch string) bool {
	b, _, err := c.gc.GetRepoBranch(owner, repo, branch)
	if err != nil {
		return false
	}

	return b.Name == branch
}

func (c *Client) allowsPages(owner, repo string) (bool, bool) {
	if strings.HasSuffix(repo, ".fluffy.pw") {
		return true, true
	}

	topics, err := c.repoTopics(owner, repo)
	if err != nil {
		return false, false
	}

	for _, topic := range topics {
		if topic == c.giteapagesAllowAll {
			return true, true
		}
	}

	for _, topic := range topics {
		if topic == c.giteapages {
			return true, false
		}
	}

	return false, false
}

func (c *Client) readConfig(owner, repo string) error {
	cfg, err := c.getRawFileOrLFS(owner, repo, c.giteapages+".toml", c.giteapages)
	if err != nil {
		return err
	}

	viper.SetConfigType("toml")

	return viper.ReadConfig(bytes.NewBuffer(cfg))
}

func splitName(name string) (string, string, string) {
	parts := strings.Split(name, "/")

	// parts contains: ["owner", "repo", "filepath"]
	switch len(parts) {
	case 1:
		return parts[0], "", ""
	case 2:
		return parts[0], parts[1], ""
	default:
		return parts[0], parts[1], strings.Join(parts[2:], "/")
	}
}

func validRefs(ref string, allowall bool) bool {
	if allowall {
		return true
	}

	validrefs := viper.GetStringSlice("allowedrefs")
	for _, r := range validrefs {
		if r == ref {
			return true
		}

		if r == "*" {
			return true
		}
	}

	return false
}
Initial commit 2022-10-30 22:46:54 +01:00			`package gitea`

			`import (`
			`"bytes"`
			`"fmt"`
			`"io"`
			`"io/fs"`
			`"net/http"`
			`"net/url"`
			`"strings"`
			`"sync"`

Start using gitea-sdk where possible 2022-11-01 21:50:49 +01:00			`gclient "code.gitea.io/sdk/gitea"`
Initial commit 2022-10-30 22:46:54 +01:00			`"github.com/spf13/viper"`
			`)`

			`type Client struct {`
Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`serverURL string`
			`token string`
			`giteapages string`
			`giteapagesAllowAll string`
			`gc *gclient.Client`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`func NewClient(serverURL, token, giteapages, giteapagesAllowAll string) (*Client, error) {`
Make gitea-pages variable 2022-11-01 21:22:12 +01:00			`if giteapages == "" {`
			`giteapages = "gitea-pages"`
			`}`

Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`if giteapagesAllowAll == "" {`
			`giteapagesAllowAll = "gitea-pages-allowall"`
			`}`

Start using gitea-sdk where possible 2022-11-01 21:50:49 +01:00			`gc, err := gclient.NewClient(serverURL, gclient.SetToken(token), gclient.SetGiteaVersion(""))`
			`if err != nil {`
			`return nil, err`
			`}`

Initial commit 2022-10-30 22:46:54 +01:00			`return &Client{`
Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`serverURL: serverURL,`
			`token: token,`
			`gc: gc,`
			`giteapages: giteapages,`
			`giteapagesAllowAll: giteapagesAllowAll,`
Start using gitea-sdk where possible 2022-11-01 21:50:49 +01:00			`}, nil`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

			`func (c *Client) Open(name, ref string) (fs.File, error) {`
Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`owner, repo, filepath := splitName(name)`
Add support for branch.repo.username.hostname If we have a domain configured eg giteapages.io then besides the normal user.giteapages.io and org.giteapages.io we also support repo.user.giteapages.io / repo.org.giteapages.io branch.repo.user.giteapages.io / branch.repo.org.giteapages.io 2022-11-02 00:00:02 +01:00
Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`if repo == "" {`
Adjust for yiffing-git 2024-12-14 22:00:50 +01:00			`repo = owner + ".fluffy.pw"`
Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`filepath = "index.html"`
			`}`

			`if filepath == "" {`
			`filepath = "index.html"`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

Adjust for yiffing-git 2024-12-14 22:00:50 +01:00			`isFluffyPagesRepo := strings.HasSuffix(repo, ".fluffy.pw")`
Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00
Adjust for yiffing-git 2024-12-14 22:00:50 +01:00			`limited, allowall := c.allowsPages(owner, repo)`
			`if !limited && !allowall && !isFluffyPagesRepo {`
			`return nil, fs.ErrNotExist`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`hasConfig := true`

			`if err := c.readConfig(owner, repo); err != nil {`
Adjust for yiffing-git 2024-12-14 22:00:50 +01:00			`if !isFluffyPagesRepo && !allowall {`
Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`return nil, err`
			`}`

			`hasConfig = false`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

Adjust for yiffing-git 2024-12-14 22:00:50 +01:00			`if !hasConfig && !validRefs(ref, allowall \|\| isFluffyPagesRepo) {`
Initial commit 2022-10-30 22:46:54 +01:00			`return nil, fs.ErrNotExist`
			`}`

			`res, err := c.getRawFileOrLFS(owner, repo, filepath, ref)`
			`if err != nil {`
			`return nil, err`
			`}`

			`if strings.HasSuffix(filepath, ".md") {`
			`res, err = handleMD(res)`
			`if err != nil {`
			`return nil, err`
			`}`
			`}`

			`return &openFile{`
			`content: res,`
			`name: filepath,`
			`}, nil`
			`}`

			`func (c *Client) getRawFileOrLFS(owner, repo, filepath, ref string) ([]byte, error) {`
			`var (`
			`giteaURL string`
			`err error`
			`)`

Start using gitea-sdk where possible 2022-11-01 21:50:49 +01:00			`// TODO: make pr for go-sdk`
			`// gitea sdk doesn't support "media" type for lfs/non-lfs`
Initial commit 2022-10-30 22:46:54 +01:00			`giteaURL, err = url.JoinPath(c.serverURL+"/api/v1/repos/", owner, repo, "media", filepath)`
			`if err != nil {`
			`return nil, err`
			`}`

			`giteaURL += "?ref=" + url.QueryEscape(ref)`

			`req, err := http.NewRequest(http.MethodGet, giteaURL, nil)`
			`if err != nil {`
			`return nil, err`
			`}`

			`req.Header.Add("Authorization", "token "+c.token)`

			`resp, err := http.DefaultClient.Do(req)`
			`if err != nil {`
			`return nil, err`
			`}`

			`switch resp.StatusCode {`
			`case http.StatusNotFound:`
			`return nil, fs.ErrNotExist`
			`case http.StatusOK:`
			`default:`
			`return nil, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)`
			`}`

			`res, err := io.ReadAll(resp.Body)`
			`if err != nil {`
			`return nil, err`
			`}`

			`defer resp.Body.Close()`

			`return res, nil`
			`}`

			`var bufPool = sync.Pool{`
			`New: func() any {`
			`return new(bytes.Buffer)`
			`},`
			`}`

			`func handleMD(res []byte) ([]byte, error) {`
			`meta, resbody, err := extractFrontMatter(string(res))`
			`if err != nil {`
			`return nil, err`
			`}`

			`resmd, err := markdown([]byte(resbody))`
			`if err != nil {`
			`return nil, err`
			`}`

Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`title, _ := meta["title"].(string)`

			`res = append([]byte("<!DOCTYPE html>\n<html>\n<body>\n<h1>"), []byte(title)...)`
Initial commit 2022-10-30 22:46:54 +01:00			`res = append(res, []byte("</h1>")...)`
			`res = append(res, resmd...)`
			`res = append(res, []byte("</body></html>")...)`

			`return res, nil`
			`}`

			`func (c *Client) repoTopics(owner, repo string) ([]string, error) {`
Start using gitea-sdk where possible 2022-11-01 21:50:49 +01:00			`repos, _, err := c.gc.ListRepoTopics(owner, repo, gclient.ListRepoTopicsOptions{})`
			`return repos, err`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`func (c *Client) hasRepoBranch(owner, repo, branch string) bool {`
			`b, _, err := c.gc.GetRepoBranch(owner, repo, branch)`
			`if err != nil {`
			`return false`
			`}`

			`return b.Name == branch`
			`}`

Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`func (c *Client) allowsPages(owner, repo string) (bool, bool) {`
Adjust for yiffing-git 2024-12-14 22:00:50 +01:00			`if strings.HasSuffix(repo, ".fluffy.pw") {`
			`return true, true`
			`}`

Initial commit 2022-10-30 22:46:54 +01:00			`topics, err := c.repoTopics(owner, repo)`
			`if err != nil {`
Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`return false, false`
			`}`

			`for _, topic := range topics {`
			`if topic == c.giteapagesAllowAll {`
			`return true, true`
			`}`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

			`for _, topic := range topics {`
Make gitea-pages variable 2022-11-01 21:22:12 +01:00			`if topic == c.giteapages {`
Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`return true, false`
Initial commit 2022-10-30 22:46:54 +01:00			`}`
			`}`

Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`return false, false`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

			`func (c *Client) readConfig(owner, repo string) error {`
Make gitea-pages variable 2022-11-01 21:22:12 +01:00			`cfg, err := c.getRawFileOrLFS(owner, repo, c.giteapages+".toml", c.giteapages)`
Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`if err != nil {`
Initial commit 2022-10-30 22:46:54 +01:00			`return err`
			`}`

			`viper.SetConfigType("toml")`

Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`return viper.ReadConfig(bytes.NewBuffer(cfg))`
Initial commit 2022-10-30 22:46:54 +01:00			`}`

Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`func splitName(name string) (string, string, string) {`
Initial commit 2022-10-30 22:46:54 +01:00			`parts := strings.Split(name, "/")`

			`// parts contains: ["owner", "repo", "filepath"]`
Add support for a gitea-pages repo with gitea-pages branch on the root If we don't find a repo, we search for the gitea-pages repo if this exists, has the gitea-pages topic tag and has a gitea-pages branch we will use this to do a file lookup. We don't need a gitea-pages.toml config file for this repo. 2022-11-01 23:21:52 +01:00			`switch len(parts) {`
			`case 1:`
			`return parts[0], "", ""`
			`case 2:`
			`return parts[0], parts[1], ""`
			`default:`
			`return parts[0], parts[1], strings.Join(parts[2:], "/")`
Initial commit 2022-10-30 22:46:54 +01:00			`}`
			`}`

Add support for gitea-pages-allowall repo topic tag If a repo has been tagged with gitea-pages-allowall we don't need an extra gitea-pages branch with a toml configuration. This makes it easier for repos that can just expose every branch 2022-11-02 18:53:32 +01:00			`func validRefs(ref string, allowall bool) bool {`
			`if allowall {`
			`return true`
			`}`

Initial commit 2022-10-30 22:46:54 +01:00			`validrefs := viper.GetStringSlice("allowedrefs")`
			`for _, r := range validrefs {`
			`if r == ref {`
			`return true`
			`}`

			`if r == "*" {`
			`return true`
			`}`
			`}`

			`return false`
			`}`