2021-12-05 13:47:33 +00:00
|
|
|
package upstream
|
|
|
|
|
|
|
|
import (
|
2022-08-28 18:54:17 +00:00
|
|
|
"errors"
|
|
|
|
"io"
|
|
|
|
"net/http"
|
|
|
|
"strings"
|
2021-12-05 13:47:33 +00:00
|
|
|
"time"
|
2022-08-28 18:54:17 +00:00
|
|
|
|
|
|
|
"github.com/rs/zerolog/log"
|
|
|
|
|
|
|
|
"codeberg.org/codeberg/pages/html"
|
|
|
|
"codeberg.org/codeberg/pages/server/context"
|
|
|
|
"codeberg.org/codeberg/pages/server/gitea"
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
headerContentType = "Content-Type"
|
|
|
|
headerETag = "ETag"
|
|
|
|
headerLastModified = "Last-Modified"
|
|
|
|
headerIfModifiedSince = "If-Modified-Since"
|
2022-09-18 19:56:56 +00:00
|
|
|
|
|
|
|
rawMime = "text/plain; charset=utf-8"
|
2021-12-05 13:47:33 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// upstreamIndexPages lists pages that may be considered as index pages for directories.
|
|
|
|
var upstreamIndexPages = []string{
|
|
|
|
"index.html",
|
|
|
|
}
|
|
|
|
|
2022-06-12 01:50:00 +00:00
|
|
|
// upstreamNotFoundPages lists pages that may be considered as custom 404 Not Found pages.
|
|
|
|
var upstreamNotFoundPages = []string{
|
|
|
|
"404.html",
|
|
|
|
}
|
|
|
|
|
2021-12-05 13:47:33 +00:00
|
|
|
// Options provides various options for the upstream request.
|
|
|
|
type Options struct {
|
2021-12-05 18:53:23 +00:00
|
|
|
TargetOwner,
|
|
|
|
TargetRepo,
|
|
|
|
TargetBranch,
|
|
|
|
TargetPath,
|
|
|
|
|
2022-08-28 13:13:11 +00:00
|
|
|
// Used for debugging purposes.
|
|
|
|
Host string
|
|
|
|
|
2022-09-18 19:56:56 +00:00
|
|
|
TryIndexPages bool
|
|
|
|
BranchTimestamp time.Time
|
2021-12-05 16:57:54 +00:00
|
|
|
// internal
|
|
|
|
appendTrailingSlash bool
|
|
|
|
redirectIfExists string
|
2022-09-18 19:56:56 +00:00
|
|
|
|
|
|
|
ServeRaw bool
|
2021-12-05 13:47:33 +00:00
|
|
|
}
|
2022-08-28 18:54:17 +00:00
|
|
|
|
|
|
|
// Upstream requests a file from the Gitea API at GiteaRoot and writes it to the request context.
|
|
|
|
func (o *Options) Upstream(ctx *context.Context, giteaClient *gitea.Client) (final bool) {
|
|
|
|
log := log.With().Strs("upstream", []string{o.TargetOwner, o.TargetRepo, o.TargetBranch, o.TargetPath}).Logger()
|
|
|
|
|
|
|
|
// Check if the branch exists and when it was modified
|
|
|
|
if o.BranchTimestamp.IsZero() {
|
|
|
|
branch := GetBranchTimestamp(giteaClient, o.TargetOwner, o.TargetRepo, o.TargetBranch)
|
|
|
|
|
|
|
|
if branch == nil {
|
|
|
|
html.ReturnErrorPage(ctx, "", http.StatusFailedDependency)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
o.TargetBranch = branch.Branch
|
|
|
|
o.BranchTimestamp = branch.Timestamp
|
|
|
|
}
|
|
|
|
|
|
|
|
if o.TargetOwner == "" || o.TargetRepo == "" || o.TargetBranch == "" {
|
|
|
|
html.ReturnErrorPage(ctx, "", http.StatusBadRequest)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if the browser has a cached version
|
|
|
|
if ifModifiedSince, err := time.Parse(time.RFC1123, string(ctx.Response().Header.Get(headerIfModifiedSince))); err == nil {
|
|
|
|
if !ifModifiedSince.Before(o.BranchTimestamp) {
|
|
|
|
ctx.RespWriter.WriteHeader(http.StatusNotModified)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
log.Debug().Msg("preparations")
|
|
|
|
|
2022-09-18 19:56:56 +00:00
|
|
|
reader, res, err := giteaClient.ServeRawContent(o.TargetOwner, o.TargetRepo, o.TargetBranch, o.TargetPath)
|
|
|
|
if reader != nil {
|
|
|
|
defer reader.Close()
|
|
|
|
}
|
2022-08-28 18:54:17 +00:00
|
|
|
log.Debug().Msg("acquisition")
|
|
|
|
|
|
|
|
// Handle errors
|
|
|
|
if (err != nil && errors.Is(err, gitea.ErrorNotFound)) || (res == nil) {
|
|
|
|
if o.TryIndexPages {
|
|
|
|
// copy the o struct & try if an index page exists
|
|
|
|
optionsForIndexPages := *o
|
|
|
|
optionsForIndexPages.TryIndexPages = false
|
|
|
|
optionsForIndexPages.appendTrailingSlash = true
|
|
|
|
for _, indexPage := range upstreamIndexPages {
|
|
|
|
optionsForIndexPages.TargetPath = strings.TrimSuffix(o.TargetPath, "/") + "/" + indexPage
|
|
|
|
if optionsForIndexPages.Upstream(ctx, giteaClient) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// compatibility fix for GitHub Pages (/example → /example.html)
|
|
|
|
optionsForIndexPages.appendTrailingSlash = false
|
|
|
|
optionsForIndexPages.redirectIfExists = strings.TrimSuffix(ctx.Path(), "/") + ".html"
|
|
|
|
optionsForIndexPages.TargetPath = o.TargetPath + ".html"
|
|
|
|
if optionsForIndexPages.Upstream(ctx, giteaClient) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Response().StatusCode = http.StatusNotFound
|
|
|
|
if o.TryIndexPages {
|
|
|
|
// copy the o struct & try if a not found page exists
|
|
|
|
optionsForNotFoundPages := *o
|
|
|
|
optionsForNotFoundPages.TryIndexPages = false
|
|
|
|
optionsForNotFoundPages.appendTrailingSlash = false
|
|
|
|
for _, notFoundPage := range upstreamNotFoundPages {
|
|
|
|
optionsForNotFoundPages.TargetPath = "/" + notFoundPage
|
|
|
|
if optionsForNotFoundPages.Upstream(ctx, giteaClient) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
if res != nil && (err != nil || res.StatusCode != http.StatusOK) {
|
|
|
|
log.Printf("Couldn't fetch contents (status code %d): %v\n", res.StatusCode, err)
|
|
|
|
html.ReturnErrorPage(ctx, "", http.StatusInternalServerError)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// Append trailing slash if missing (for index files), and redirect to fix filenames in general
|
|
|
|
// o.appendTrailingSlash is only true when looking for index pages
|
|
|
|
if o.appendTrailingSlash && !strings.HasSuffix(ctx.Path(), "/") {
|
|
|
|
ctx.Redirect(ctx.Path()+"/", http.StatusTemporaryRedirect)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if strings.HasSuffix(ctx.Path(), "/index.html") {
|
|
|
|
ctx.Redirect(strings.TrimSuffix(ctx.Path(), "index.html"), http.StatusTemporaryRedirect)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if o.redirectIfExists != "" {
|
|
|
|
ctx.Redirect(o.redirectIfExists, http.StatusTemporaryRedirect)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
log.Debug().Msg("error handling")
|
|
|
|
|
2022-09-18 19:56:56 +00:00
|
|
|
// Set ETag & MIME
|
2022-08-28 18:54:17 +00:00
|
|
|
if res != nil {
|
|
|
|
ctx.Response().Header.Set(headerETag, res.Header.Get(headerETag))
|
2022-09-18 19:56:56 +00:00
|
|
|
if o.ServeRaw {
|
|
|
|
ctx.Response().Header.Set(headerContentType, res.Header.Get(headerContentType))
|
|
|
|
} else {
|
|
|
|
ctx.Response().Header.Set(headerContentType, rawMime)
|
|
|
|
}
|
2022-08-28 18:54:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.Response().StatusCode != http.StatusNotFound {
|
|
|
|
// Everything's okay so far
|
|
|
|
ctx.Response().StatusCode = http.StatusOK
|
|
|
|
}
|
|
|
|
ctx.Response().Header.Set(headerLastModified, o.BranchTimestamp.In(time.UTC).Format(time.RFC1123))
|
|
|
|
|
|
|
|
log.Debug().Msg("response preparations")
|
|
|
|
|
|
|
|
// Write the response body to the original request
|
|
|
|
if reader != nil {
|
|
|
|
_, err := io.Copy(ctx.RespWriter, reader)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("Couldn't write body: %s\n", err)
|
|
|
|
html.ReturnErrorPage(ctx, "", http.StatusInternalServerError)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Debug().Msg("response")
|
|
|
|
|
|
|
|
return true
|
|
|
|
}
|